/////////////////////////////////////////////////
// This file has been automatically generated  //
// Do not modify this file                     //
/////////////////////////////////////////////////

#include "StubApiCalls.h"

#ifndef LOAD_JUMPTABLE_STATICALLY
#define CHECK_GL_CALL(call)\
if ( JT.call == NULL ) {\
  ((unsigned long *)(&JT))[APICall_##call] = (unsigned long)JT.wglGetProcAddress(#call);\
  if ( JT.call == NULL )\
  {popup(#call,"Call unsupported. Cannot be found in current gl implementation");}\
}\
if ( JT.call != NULL )
#else
#define CHECK_GL_CALL(call)\
if ( JT.call == NULL )\
{ popup(#call,"Call unsupported. Cannot be found in current gl implementation"); }\
else
#endif

#define CHECK_USER_CALL(call) if ( UCT.call != NULL )

#define READ_PARAM(unionSelector,whichParam)\
    if ( paramFlag & (1 << whichParam) )\
    {\
        Param dummy;\
        TR.read(&dummy.unionSelector);\
        paramFlag &= ~(1 << whichParam);\
    }\
    else\
        TR.read(&param[whichParam].unionSelector);

#define READ_ENUM_PARAM(whichParam)\
    if ( paramFlag & (1 << whichParam) )\
    {\
        Param dummy;\
        TR.readEnum(&dummy.uv32bit);\
        paramFlag &= ~(1 << whichParam);\
    }\
    else\
        TR.readEnum(&param[whichParam].uv32bit);

#define READ_ORING_PARAM(whichParam)\
    if ( paramFlag & (1 << whichParam) )\
    {\
        Param dummy;\
        TR.readOring(&dummy.uv32bit);\
        paramFlag &= ~(1 << whichParam);\
    }\
    else\
        TR.readOring(&param[whichParam].uv32bit);

#define READ_DOUBLE_PARAM(whichParam)\
    if ( paramFlag & (1 << whichParam) )\
    {\
        Param dummy;\
        TR.readDouble(&dummy.fv64bit);\
        paramFlag &= ~(1 << whichParam);\
    }\
    else\
        TR.readDouble(&param[whichParam].fv64bit);

#define READ_BOOLEAN_PARAM(whichParam)\
    if ( paramFlag & (1 << whichParam) )\
    {\
        Param dummy;\
        TR.readBoolean(&dummy.boolean);\
        paramFlag &= ~(1 << whichParam);\
    }\
    else\
        TR.readBoolean(&param[whichParam].boolean);

#define READ_ARRAY_PARAM(whichParam, buf, mode)\
    if ( paramFlag & (1 << whichParam) )\
    {\
        Param dummy;\
        TR.readArray(&dummy.ptr, buf, sizeof(buf), mode);\
        paramFlag &= ~(1 << whichParam);\
    }\
    else\
        TR.readArray(&param[whichParam].ptr, buf, sizeof(buf), mode);

static int paramFlag = 0;
static Param param[32];
static unsigned int maxParam = 0;

Param getLastCallParameter(unsigned int iParam)
{
    if ( iParam >= maxParam )
        panic("StubApiCalls", "getLastCallParameter", "The parameter does not exist");
    return param[iParam];
}

void setLastCallParameter(unsigned int iParam, const Param& p)
{
    // if ( iParam >= maxParam )
    //    panic("StubApiCalls", "setLastCallParameter", "The parameter does not exist");
    param[iParam] = p;
    paramFlag |= (1 << iParam);
}

void STUB_glAccum( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glAccum( GLenum op, GLfloat value )
    maxParam = 2;
    READ_ENUM_PARAM(0);
    READ_PARAM(fv32bit,1);
    TR.skipLine();
    CHECK_USER_CALL(glAccum)
        UCT.glAccum(param[0].uv32bit, param[1].fv32bit);
    CHECK_GL_CALL(glAccum)
        JT.glAccum(param[0].uv32bit, param[1].fv32bit);
}

void STUB_glActiveStencilFaceEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glActiveStencilFaceEXT( GLenum )
    maxParam = 1;
    READ_ENUM_PARAM(0);
    TR.skipLine();
    CHECK_USER_CALL(glActiveStencilFaceEXT)
        UCT.glActiveStencilFaceEXT(param[0].uv32bit);
    CHECK_GL_CALL(glActiveStencilFaceEXT)
        JT.glActiveStencilFaceEXT(param[0].uv32bit);
}

void STUB_glActiveTexture( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glActiveTexture( GLenum texture )
    maxParam = 1;
    READ_ENUM_PARAM(0);
    TR.skipLine();
    CHECK_USER_CALL(glActiveTexture)
        UCT.glActiveTexture(param[0].uv32bit);
    CHECK_GL_CALL(glActiveTexture)
        JT.glActiveTexture(param[0].uv32bit);
}

void STUB_glActiveTextureARB( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glActiveTextureARB( GLenum texture )
    maxParam = 1;
    READ_ENUM_PARAM(0);
    TR.skipLine();
    CHECK_USER_CALL(glActiveTextureARB)
        UCT.glActiveTextureARB(param[0].uv32bit);
    CHECK_GL_CALL(glActiveTextureARB)
        JT.glActiveTextureARB(param[0].uv32bit);
}

void STUB_glActiveVaryingNV( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glActiveVaryingNV( GLuint, const GLchar * )
    // Call not playable
    TR.skipCall();
}

void STUB_glAlphaFragmentOp1ATI( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glAlphaFragmentOp1ATI( GLenum, GLuint, GLuint, GLuint, GLuint, GLuint )
    maxParam = 6;
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_ENUM_PARAM(2);
    READ_ENUM_PARAM(3);
    READ_ENUM_PARAM(4);
    READ_ENUM_PARAM(5);
    TR.skipLine();
    CHECK_USER_CALL(glAlphaFragmentOp1ATI)
        UCT.glAlphaFragmentOp1ATI(param[0].uv32bit, param[1].uv32bit, param[2].uv32bit, param[3].uv32bit, param[4].uv32bit, param[5].uv32bit);
    CHECK_GL_CALL(glAlphaFragmentOp1ATI)
        JT.glAlphaFragmentOp1ATI(param[0].uv32bit, param[1].uv32bit, param[2].uv32bit, param[3].uv32bit, param[4].uv32bit, param[5].uv32bit);
}

void STUB_glAlphaFragmentOp2ATI( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glAlphaFragmentOp2ATI( GLenum, GLuint, GLuint, GLuint, GLuint, GLuint, GLuint, GLuint, GLuint )
    maxParam = 9;
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_ENUM_PARAM(2);
    READ_ENUM_PARAM(3);
    READ_ENUM_PARAM(4);
    READ_ENUM_PARAM(5);
    READ_ENUM_PARAM(6);
    READ_ENUM_PARAM(7);
    READ_ENUM_PARAM(8);
    TR.skipLine();
    CHECK_USER_CALL(glAlphaFragmentOp2ATI)
        UCT.glAlphaFragmentOp2ATI(param[0].uv32bit, param[1].uv32bit, param[2].uv32bit, param[3].uv32bit, param[4].uv32bit, param[5].uv32bit, param[6].uv32bit, param[7].uv32bit, param[8].uv32bit);
    CHECK_GL_CALL(glAlphaFragmentOp2ATI)
        JT.glAlphaFragmentOp2ATI(param[0].uv32bit, param[1].uv32bit, param[2].uv32bit, param[3].uv32bit, param[4].uv32bit, param[5].uv32bit, param[6].uv32bit, param[7].uv32bit, param[8].uv32bit);
}

void STUB_glAlphaFragmentOp3ATI( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glAlphaFragmentOp3ATI( GLenum, GLuint, GLuint, GLuint, GLuint, GLuint, GLuint, GLuint, GLuint, GLuint, GLuint, GLuint )
    maxParam = 12;
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_ENUM_PARAM(2);
    READ_ENUM_PARAM(3);
    READ_ENUM_PARAM(4);
    READ_ENUM_PARAM(5);
    READ_ENUM_PARAM(6);
    READ_ENUM_PARAM(7);
    READ_ENUM_PARAM(8);
    READ_ENUM_PARAM(9);
    READ_ENUM_PARAM(10);
    READ_ENUM_PARAM(11);
    TR.skipLine();
    CHECK_USER_CALL(glAlphaFragmentOp3ATI)
        UCT.glAlphaFragmentOp3ATI(param[0].uv32bit, param[1].uv32bit, param[2].uv32bit, param[3].uv32bit, param[4].uv32bit, param[5].uv32bit, param[6].uv32bit, param[7].uv32bit, param[8].uv32bit, param[9].uv32bit, param[10].uv32bit, param[11].uv32bit);
    CHECK_GL_CALL(glAlphaFragmentOp3ATI)
        JT.glAlphaFragmentOp3ATI(param[0].uv32bit, param[1].uv32bit, param[2].uv32bit, param[3].uv32bit, param[4].uv32bit, param[5].uv32bit, param[6].uv32bit, param[7].uv32bit, param[8].uv32bit, param[9].uv32bit, param[10].uv32bit, param[11].uv32bit);
}

void STUB_glAlphaFunc( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glAlphaFunc( GLenum func, GLclampf ref )
    maxParam = 2;
    READ_ENUM_PARAM(0);
    READ_PARAM(fv32bit,1);
    TR.skipLine();
    CHECK_USER_CALL(glAlphaFunc)
        UCT.glAlphaFunc(param[0].uv32bit, param[1].fv32bit);
    CHECK_GL_CALL(glAlphaFunc)
        JT.glAlphaFunc(param[0].uv32bit, param[1].fv32bit);
}

void STUB_glApplyTextureEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glApplyTextureEXT( GLenum )
    maxParam = 1;
    READ_ENUM_PARAM(0);
    TR.skipLine();
    CHECK_USER_CALL(glApplyTextureEXT)
        UCT.glApplyTextureEXT(param[0].uv32bit);
    CHECK_GL_CALL(glApplyTextureEXT)
        JT.glApplyTextureEXT(param[0].uv32bit);
}

void STUB_glAreProgramsResidentNV( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // GLboolean glAreProgramsResidentNV( GLsizei, const GLuint *, GLboolean * )
    maxParam = 3;
    char buffer0[16*4096];
    char buffer1[16*4096];
    READ_PARAM(v32bit,0);
    READ_ARRAY_PARAM( 1, buffer0, TraceReader::TEXT_INT);
    READ_ARRAY_PARAM( 2, buffer1, TraceReader::TEXT_BYTE);
    TR.skipResult();
    TR.skipLine();
    CHECK_USER_CALL(glAreProgramsResidentNV)
        UCT.glAreProgramsResidentNV(param[0].v32bit, (const GLuint *)param[1].ptr, (GLboolean *)param[2].ptr);
    CHECK_GL_CALL(glAreProgramsResidentNV)
        JT.glAreProgramsResidentNV(param[0].v32bit, (const GLuint *)param[1].ptr, (GLboolean *)param[2].ptr);
}

void STUB_glAreTexturesResident( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // GLboolean glAreTexturesResident( GLsizei n, const GLuint *textures, GLboolean *residences )
    maxParam = 3;
    char buffer0[16*4096];
    char buffer1[16*4096];
    READ_PARAM(v32bit,0);
    READ_ARRAY_PARAM( 1, buffer0, TraceReader::TEXT_INT);
    READ_ARRAY_PARAM( 2, buffer1, TraceReader::TEXT_BYTE);
    TR.skipResult();
    TR.skipLine();
    CHECK_USER_CALL(glAreTexturesResident)
        UCT.glAreTexturesResident(param[0].v32bit, (const GLuint *)param[1].ptr, (GLboolean *)param[2].ptr);
    CHECK_GL_CALL(glAreTexturesResident)
        JT.glAreTexturesResident(param[0].v32bit, (const GLuint *)param[1].ptr, (GLboolean *)param[2].ptr);
}

void STUB_glAreTexturesResidentEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // GLboolean glAreTexturesResidentEXT( GLsizei, const GLuint *, GLboolean * )
    maxParam = 3;
    char buffer0[16*4096];
    char buffer1[16*4096];
    READ_PARAM(v32bit,0);
    READ_ARRAY_PARAM( 1, buffer0, TraceReader::TEXT_INT);
    READ_ARRAY_PARAM( 2, buffer1, TraceReader::TEXT_BYTE);
    TR.skipResult();
    TR.skipLine();
    CHECK_USER_CALL(glAreTexturesResidentEXT)
        UCT.glAreTexturesResidentEXT(param[0].v32bit, (const GLuint *)param[1].ptr, (GLboolean *)param[2].ptr);
    CHECK_GL_CALL(glAreTexturesResidentEXT)
        JT.glAreTexturesResidentEXT(param[0].v32bit, (const GLuint *)param[1].ptr, (GLboolean *)param[2].ptr);
}

void STUB_glArrayElement( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glArrayElement( GLint i )
    maxParam = 1;
    READ_PARAM(v32bit,0);
    TR.skipLine();
    CHECK_USER_CALL(glArrayElement)
        UCT.glArrayElement(param[0].v32bit);
    CHECK_GL_CALL(glArrayElement)
        JT.glArrayElement(param[0].v32bit);
}

void STUB_glArrayElementEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glArrayElementEXT( GLint )
    maxParam = 1;
    READ_PARAM(v32bit,0);
    TR.skipLine();
    CHECK_USER_CALL(glArrayElementEXT)
        UCT.glArrayElementEXT(param[0].v32bit);
    CHECK_GL_CALL(glArrayElementEXT)
        JT.glArrayElementEXT(param[0].v32bit);
}

void STUB_glArrayObjectATI( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glArrayObjectATI( GLenum, GLint, GLenum, GLsizei, GLuint, GLuint )
    maxParam = 6;
    READ_ENUM_PARAM(0);
    READ_PARAM(v32bit,1);
    READ_ENUM_PARAM(2);
    READ_PARAM(v32bit,3);
    READ_ENUM_PARAM(4);
    READ_ENUM_PARAM(5);
    TR.skipLine();
    CHECK_USER_CALL(glArrayObjectATI)
        UCT.glArrayObjectATI(param[0].uv32bit, param[1].v32bit, param[2].uv32bit, param[3].v32bit, param[4].uv32bit, param[5].uv32bit);
    CHECK_GL_CALL(glArrayObjectATI)
        JT.glArrayObjectATI(param[0].uv32bit, param[1].v32bit, param[2].uv32bit, param[3].v32bit, param[4].uv32bit, param[5].uv32bit);
}

void STUB_glAsyncMarkerSGIX( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glAsyncMarkerSGIX( GLuint )
    maxParam = 1;
    READ_ENUM_PARAM(0);
    TR.skipLine();
    CHECK_USER_CALL(glAsyncMarkerSGIX)
        UCT.glAsyncMarkerSGIX(param[0].uv32bit);
    CHECK_GL_CALL(glAsyncMarkerSGIX)
        JT.glAsyncMarkerSGIX(param[0].uv32bit);
}

void STUB_glAttachObjectARB( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glAttachObjectARB( GLhandleARB, GLhandleARB )
    maxParam = 2;
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    TR.skipLine();
    CHECK_USER_CALL(glAttachObjectARB)
        UCT.glAttachObjectARB(param[0].uv32bit, param[1].uv32bit);
    CHECK_GL_CALL(glAttachObjectARB)
        JT.glAttachObjectARB(param[0].uv32bit, param[1].uv32bit);
}

void STUB_glAttachShader( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glAttachShader( GLuint, GLuint )
    maxParam = 2;
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    TR.skipLine();
    CHECK_USER_CALL(glAttachShader)
        UCT.glAttachShader(param[0].uv32bit, param[1].uv32bit);
    CHECK_GL_CALL(glAttachShader)
        JT.glAttachShader(param[0].uv32bit, param[1].uv32bit);
}

void STUB_glBegin( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glBegin( GLenum mode )
    maxParam = 1;
    READ_ENUM_PARAM(0);
    TR.skipLine();
    CHECK_USER_CALL(glBegin)
        UCT.glBegin(param[0].uv32bit);
    CHECK_GL_CALL(glBegin)
        JT.glBegin(param[0].uv32bit);
}

void STUB_glBeginConditionalRender( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glBeginConditionalRender( GLuint, GLenum )
    maxParam = 2;
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    TR.skipLine();
    CHECK_USER_CALL(glBeginConditionalRender)
        UCT.glBeginConditionalRender(param[0].uv32bit, param[1].uv32bit);
    CHECK_GL_CALL(glBeginConditionalRender)
        JT.glBeginConditionalRender(param[0].uv32bit, param[1].uv32bit);
}

void STUB_glBeginConditionalRenderNV( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glBeginConditionalRenderNV( GLuint, GLenum )
    maxParam = 2;
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    TR.skipLine();
    CHECK_USER_CALL(glBeginConditionalRenderNV)
        UCT.glBeginConditionalRenderNV(param[0].uv32bit, param[1].uv32bit);
    CHECK_GL_CALL(glBeginConditionalRenderNV)
        JT.glBeginConditionalRenderNV(param[0].uv32bit, param[1].uv32bit);
}

void STUB_glBeginFragmentShaderATI( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glBeginFragmentShaderATI(  )
    maxParam = 0;
    TR.skipLine();
    CHECK_USER_CALL(glBeginFragmentShaderATI)
        UCT.glBeginFragmentShaderATI();
    CHECK_GL_CALL(glBeginFragmentShaderATI)
        JT.glBeginFragmentShaderATI();
}

void STUB_glBeginOcclusionQueryNV( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glBeginOcclusionQueryNV( GLuint )
    maxParam = 1;
    READ_ENUM_PARAM(0);
    TR.skipLine();
    CHECK_USER_CALL(glBeginOcclusionQueryNV)
        UCT.glBeginOcclusionQueryNV(param[0].uv32bit);
    CHECK_GL_CALL(glBeginOcclusionQueryNV)
        JT.glBeginOcclusionQueryNV(param[0].uv32bit);
}

void STUB_glBeginPerfMonitorAMD( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glBeginPerfMonitorAMD( GLuint )
    maxParam = 1;
    READ_ENUM_PARAM(0);
    TR.skipLine();
    CHECK_USER_CALL(glBeginPerfMonitorAMD)
        UCT.glBeginPerfMonitorAMD(param[0].uv32bit);
    CHECK_GL_CALL(glBeginPerfMonitorAMD)
        JT.glBeginPerfMonitorAMD(param[0].uv32bit);
}

void STUB_glBeginQuery( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glBeginQuery( GLenum, GLuint )
    maxParam = 2;
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    TR.skipLine();
    CHECK_USER_CALL(glBeginQuery)
        UCT.glBeginQuery(param[0].uv32bit, param[1].uv32bit);
    CHECK_GL_CALL(glBeginQuery)
        JT.glBeginQuery(param[0].uv32bit, param[1].uv32bit);
}

void STUB_glBeginQueryARB( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glBeginQueryARB( GLenum, GLuint )
    maxParam = 2;
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    TR.skipLine();
    CHECK_USER_CALL(glBeginQueryARB)
        UCT.glBeginQueryARB(param[0].uv32bit, param[1].uv32bit);
    CHECK_GL_CALL(glBeginQueryARB)
        JT.glBeginQueryARB(param[0].uv32bit, param[1].uv32bit);
}

void STUB_glBeginTransformFeedback( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glBeginTransformFeedback( GLenum )
    maxParam = 1;
    READ_ENUM_PARAM(0);
    TR.skipLine();
    CHECK_USER_CALL(glBeginTransformFeedback)
        UCT.glBeginTransformFeedback(param[0].uv32bit);
    CHECK_GL_CALL(glBeginTransformFeedback)
        JT.glBeginTransformFeedback(param[0].uv32bit);
}

void STUB_glBeginTransformFeedbackEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glBeginTransformFeedbackEXT( GLenum )
    maxParam = 1;
    READ_ENUM_PARAM(0);
    TR.skipLine();
    CHECK_USER_CALL(glBeginTransformFeedbackEXT)
        UCT.glBeginTransformFeedbackEXT(param[0].uv32bit);
    CHECK_GL_CALL(glBeginTransformFeedbackEXT)
        JT.glBeginTransformFeedbackEXT(param[0].uv32bit);
}

void STUB_glBeginTransformFeedbackNV( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glBeginTransformFeedbackNV( GLenum )
    maxParam = 1;
    READ_ENUM_PARAM(0);
    TR.skipLine();
    CHECK_USER_CALL(glBeginTransformFeedbackNV)
        UCT.glBeginTransformFeedbackNV(param[0].uv32bit);
    CHECK_GL_CALL(glBeginTransformFeedbackNV)
        JT.glBeginTransformFeedbackNV(param[0].uv32bit);
}

void STUB_glBeginVertexShaderEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glBeginVertexShaderEXT(  )
    maxParam = 0;
    TR.skipLine();
    CHECK_USER_CALL(glBeginVertexShaderEXT)
        UCT.glBeginVertexShaderEXT();
    CHECK_GL_CALL(glBeginVertexShaderEXT)
        JT.glBeginVertexShaderEXT();
}

void STUB_glBindAttribLocation( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glBindAttribLocation( GLuint, GLuint, const GLchar * )
    // Call not playable
    TR.skipCall();
}

void STUB_glBindAttribLocationARB( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glBindAttribLocationARB( GLhandleARB, GLuint, const GLcharARB * )
    maxParam = 3;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_ARRAY_PARAM( 2, buffer0, TraceReader::TEXT_BYTE);
    TR.skipLine();
    CHECK_USER_CALL(glBindAttribLocationARB)
        UCT.glBindAttribLocationARB(param[0].uv32bit, param[1].uv32bit, (const GLcharARB *)param[2].ptr);
    CHECK_GL_CALL(glBindAttribLocationARB)
        JT.glBindAttribLocationARB(param[0].uv32bit, param[1].uv32bit, (const GLcharARB *)param[2].ptr);
}

void STUB_glBindBuffer( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glBindBuffer( GLenum, GLuint )
    maxParam = 2;
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    TR.skipLine();
    CHECK_USER_CALL(glBindBuffer)
        UCT.glBindBuffer(param[0].uv32bit, param[1].uv32bit);
    CHECK_GL_CALL(glBindBuffer)
        JT.glBindBuffer(param[0].uv32bit, param[1].uv32bit);
}

void STUB_glBindBufferARB( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glBindBufferARB( GLenum, GLuint )
    maxParam = 2;
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    TR.skipLine();
    CHECK_USER_CALL(glBindBufferARB)
        UCT.glBindBufferARB(param[0].uv32bit, param[1].uv32bit);
    CHECK_GL_CALL(glBindBufferARB)
        JT.glBindBufferARB(param[0].uv32bit, param[1].uv32bit);
}

void STUB_glBindBufferBase( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glBindBufferBase( GLenum, GLuint, GLuint )
    maxParam = 3;
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_ENUM_PARAM(2);
    TR.skipLine();
    CHECK_USER_CALL(glBindBufferBase)
        UCT.glBindBufferBase(param[0].uv32bit, param[1].uv32bit, param[2].uv32bit);
    CHECK_GL_CALL(glBindBufferBase)
        JT.glBindBufferBase(param[0].uv32bit, param[1].uv32bit, param[2].uv32bit);
}

void STUB_glBindBufferBaseEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glBindBufferBaseEXT( GLenum, GLuint, GLuint )
    maxParam = 3;
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_ENUM_PARAM(2);
    TR.skipLine();
    CHECK_USER_CALL(glBindBufferBaseEXT)
        UCT.glBindBufferBaseEXT(param[0].uv32bit, param[1].uv32bit, param[2].uv32bit);
    CHECK_GL_CALL(glBindBufferBaseEXT)
        JT.glBindBufferBaseEXT(param[0].uv32bit, param[1].uv32bit, param[2].uv32bit);
}

void STUB_glBindBufferBaseNV( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glBindBufferBaseNV( GLenum, GLuint, GLuint )
    maxParam = 3;
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_ENUM_PARAM(2);
    TR.skipLine();
    CHECK_USER_CALL(glBindBufferBaseNV)
        UCT.glBindBufferBaseNV(param[0].uv32bit, param[1].uv32bit, param[2].uv32bit);
    CHECK_GL_CALL(glBindBufferBaseNV)
        JT.glBindBufferBaseNV(param[0].uv32bit, param[1].uv32bit, param[2].uv32bit);
}

void STUB_glBindBufferOffsetEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glBindBufferOffsetEXT( GLenum, GLuint, GLuint, GLintptr )
    maxParam = 4;
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_ENUM_PARAM(2);
    READ_PARAM(v32bit,3);
    TR.skipLine();
    CHECK_USER_CALL(glBindBufferOffsetEXT)
        UCT.glBindBufferOffsetEXT(param[0].uv32bit, param[1].uv32bit, param[2].uv32bit, param[3].v32bit);
    CHECK_GL_CALL(glBindBufferOffsetEXT)
        JT.glBindBufferOffsetEXT(param[0].uv32bit, param[1].uv32bit, param[2].uv32bit, param[3].v32bit);
}

void STUB_glBindBufferOffsetNV( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glBindBufferOffsetNV( GLenum, GLuint, GLuint, GLintptr )
    maxParam = 4;
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_ENUM_PARAM(2);
    READ_PARAM(v32bit,3);
    TR.skipLine();
    CHECK_USER_CALL(glBindBufferOffsetNV)
        UCT.glBindBufferOffsetNV(param[0].uv32bit, param[1].uv32bit, param[2].uv32bit, param[3].v32bit);
    CHECK_GL_CALL(glBindBufferOffsetNV)
        JT.glBindBufferOffsetNV(param[0].uv32bit, param[1].uv32bit, param[2].uv32bit, param[3].v32bit);
}

void STUB_glBindBufferRange( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glBindBufferRange( GLenum, GLuint, GLuint, GLintptr, GLsizeiptr )
    maxParam = 5;
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_ENUM_PARAM(2);
    READ_PARAM(v32bit,3);
    READ_PARAM(v32bit,4);
    TR.skipLine();
    CHECK_USER_CALL(glBindBufferRange)
        UCT.glBindBufferRange(param[0].uv32bit, param[1].uv32bit, param[2].uv32bit, param[3].v32bit, param[4].v32bit);
    CHECK_GL_CALL(glBindBufferRange)
        JT.glBindBufferRange(param[0].uv32bit, param[1].uv32bit, param[2].uv32bit, param[3].v32bit, param[4].v32bit);
}

void STUB_glBindBufferRangeEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glBindBufferRangeEXT( GLenum, GLuint, GLuint, GLintptr, GLsizeiptr )
    maxParam = 5;
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_ENUM_PARAM(2);
    READ_PARAM(v32bit,3);
    READ_PARAM(v32bit,4);
    TR.skipLine();
    CHECK_USER_CALL(glBindBufferRangeEXT)
        UCT.glBindBufferRangeEXT(param[0].uv32bit, param[1].uv32bit, param[2].uv32bit, param[3].v32bit, param[4].v32bit);
    CHECK_GL_CALL(glBindBufferRangeEXT)
        JT.glBindBufferRangeEXT(param[0].uv32bit, param[1].uv32bit, param[2].uv32bit, param[3].v32bit, param[4].v32bit);
}

void STUB_glBindBufferRangeNV( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glBindBufferRangeNV( GLenum, GLuint, GLuint, GLintptr, GLsizeiptr )
    maxParam = 5;
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_ENUM_PARAM(2);
    READ_PARAM(v32bit,3);
    READ_PARAM(v32bit,4);
    TR.skipLine();
    CHECK_USER_CALL(glBindBufferRangeNV)
        UCT.glBindBufferRangeNV(param[0].uv32bit, param[1].uv32bit, param[2].uv32bit, param[3].v32bit, param[4].v32bit);
    CHECK_GL_CALL(glBindBufferRangeNV)
        JT.glBindBufferRangeNV(param[0].uv32bit, param[1].uv32bit, param[2].uv32bit, param[3].v32bit, param[4].v32bit);
}

void STUB_glBindFragDataLocation( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glBindFragDataLocation( GLuint, GLuint, const GLchar * )
    // Call not playable
    TR.skipCall();
}

void STUB_glBindFragDataLocationEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glBindFragDataLocationEXT( GLuint, GLuint, const GLchar * )
    // Call not playable
    TR.skipCall();
}

void STUB_glBindFragmentShaderATI( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glBindFragmentShaderATI( GLuint )
    maxParam = 1;
    READ_ENUM_PARAM(0);
    TR.skipLine();
    CHECK_USER_CALL(glBindFragmentShaderATI)
        UCT.glBindFragmentShaderATI(param[0].uv32bit);
    CHECK_GL_CALL(glBindFragmentShaderATI)
        JT.glBindFragmentShaderATI(param[0].uv32bit);
}

void STUB_glBindFramebuffer( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glBindFramebuffer( GLenum, GLuint )
    maxParam = 2;
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    TR.skipLine();
    CHECK_USER_CALL(glBindFramebuffer)
        UCT.glBindFramebuffer(param[0].uv32bit, param[1].uv32bit);
    CHECK_GL_CALL(glBindFramebuffer)
        JT.glBindFramebuffer(param[0].uv32bit, param[1].uv32bit);
}

void STUB_glBindFramebufferEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glBindFramebufferEXT( GLenum, GLuint )
    maxParam = 2;
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    TR.skipLine();
    CHECK_USER_CALL(glBindFramebufferEXT)
        UCT.glBindFramebufferEXT(param[0].uv32bit, param[1].uv32bit);
    CHECK_GL_CALL(glBindFramebufferEXT)
        JT.glBindFramebufferEXT(param[0].uv32bit, param[1].uv32bit);
}

void STUB_glBindLightParameterEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // GLuint glBindLightParameterEXT( GLenum, GLenum )
    maxParam = 2;
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    TR.skipResult();
    TR.skipLine();
    CHECK_USER_CALL(glBindLightParameterEXT)
        UCT.glBindLightParameterEXT(param[0].uv32bit, param[1].uv32bit);
    CHECK_GL_CALL(glBindLightParameterEXT)
        JT.glBindLightParameterEXT(param[0].uv32bit, param[1].uv32bit);
}

void STUB_glBindMaterialParameterEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // GLuint glBindMaterialParameterEXT( GLenum, GLenum )
    maxParam = 2;
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    TR.skipResult();
    TR.skipLine();
    CHECK_USER_CALL(glBindMaterialParameterEXT)
        UCT.glBindMaterialParameterEXT(param[0].uv32bit, param[1].uv32bit);
    CHECK_GL_CALL(glBindMaterialParameterEXT)
        JT.glBindMaterialParameterEXT(param[0].uv32bit, param[1].uv32bit);
}

void STUB_glBindMultiTextureEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glBindMultiTextureEXT( GLenum, GLenum, GLuint )
    maxParam = 3;
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_ENUM_PARAM(2);
    TR.skipLine();
    CHECK_USER_CALL(glBindMultiTextureEXT)
        UCT.glBindMultiTextureEXT(param[0].uv32bit, param[1].uv32bit, param[2].uv32bit);
    CHECK_GL_CALL(glBindMultiTextureEXT)
        JT.glBindMultiTextureEXT(param[0].uv32bit, param[1].uv32bit, param[2].uv32bit);
}

void STUB_glBindParameterEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // GLuint glBindParameterEXT( GLenum )
    maxParam = 1;
    READ_ENUM_PARAM(0);
    TR.skipResult();
    TR.skipLine();
    CHECK_USER_CALL(glBindParameterEXT)
        UCT.glBindParameterEXT(param[0].uv32bit);
    CHECK_GL_CALL(glBindParameterEXT)
        JT.glBindParameterEXT(param[0].uv32bit);
}

void STUB_glBindProgramARB( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glBindProgramARB( GLenum, GLuint )
    maxParam = 2;
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    TR.skipLine();
    CHECK_USER_CALL(glBindProgramARB)
        UCT.glBindProgramARB(param[0].uv32bit, param[1].uv32bit);
    CHECK_GL_CALL(glBindProgramARB)
        JT.glBindProgramARB(param[0].uv32bit, param[1].uv32bit);
}

void STUB_glBindProgramNV( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glBindProgramNV( GLenum, GLuint )
    maxParam = 2;
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    TR.skipLine();
    CHECK_USER_CALL(glBindProgramNV)
        UCT.glBindProgramNV(param[0].uv32bit, param[1].uv32bit);
    CHECK_GL_CALL(glBindProgramNV)
        JT.glBindProgramNV(param[0].uv32bit, param[1].uv32bit);
}

void STUB_glBindRenderbuffer( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glBindRenderbuffer( GLenum, GLuint )
    maxParam = 2;
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    TR.skipLine();
    CHECK_USER_CALL(glBindRenderbuffer)
        UCT.glBindRenderbuffer(param[0].uv32bit, param[1].uv32bit);
    CHECK_GL_CALL(glBindRenderbuffer)
        JT.glBindRenderbuffer(param[0].uv32bit, param[1].uv32bit);
}

void STUB_glBindRenderbufferEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glBindRenderbufferEXT( GLenum, GLuint )
    maxParam = 2;
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    TR.skipLine();
    CHECK_USER_CALL(glBindRenderbufferEXT)
        UCT.glBindRenderbufferEXT(param[0].uv32bit, param[1].uv32bit);
    CHECK_GL_CALL(glBindRenderbufferEXT)
        JT.glBindRenderbufferEXT(param[0].uv32bit, param[1].uv32bit);
}

void STUB_glBindTexGenParameterEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // GLuint glBindTexGenParameterEXT( GLenum, GLenum, GLenum )
    maxParam = 3;
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_ENUM_PARAM(2);
    TR.skipResult();
    TR.skipLine();
    CHECK_USER_CALL(glBindTexGenParameterEXT)
        UCT.glBindTexGenParameterEXT(param[0].uv32bit, param[1].uv32bit, param[2].uv32bit);
    CHECK_GL_CALL(glBindTexGenParameterEXT)
        JT.glBindTexGenParameterEXT(param[0].uv32bit, param[1].uv32bit, param[2].uv32bit);
}

void STUB_glBindTexture( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glBindTexture( GLenum target, GLuint texture )
    maxParam = 2;
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    TR.skipLine();
    CHECK_USER_CALL(glBindTexture)
        UCT.glBindTexture(param[0].uv32bit, param[1].uv32bit);
    CHECK_GL_CALL(glBindTexture)
        JT.glBindTexture(param[0].uv32bit, param[1].uv32bit);
}

void STUB_glBindTextureEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glBindTextureEXT( GLenum, GLuint )
    maxParam = 2;
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    TR.skipLine();
    CHECK_USER_CALL(glBindTextureEXT)
        UCT.glBindTextureEXT(param[0].uv32bit, param[1].uv32bit);
    CHECK_GL_CALL(glBindTextureEXT)
        JT.glBindTextureEXT(param[0].uv32bit, param[1].uv32bit);
}

void STUB_glBindTextureUnitParameterEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // GLuint glBindTextureUnitParameterEXT( GLenum, GLenum )
    maxParam = 2;
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    TR.skipResult();
    TR.skipLine();
    CHECK_USER_CALL(glBindTextureUnitParameterEXT)
        UCT.glBindTextureUnitParameterEXT(param[0].uv32bit, param[1].uv32bit);
    CHECK_GL_CALL(glBindTextureUnitParameterEXT)
        JT.glBindTextureUnitParameterEXT(param[0].uv32bit, param[1].uv32bit);
}

void STUB_glBindTransformFeedbackNV( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glBindTransformFeedbackNV( GLenum, GLuint )
    maxParam = 2;
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    TR.skipLine();
    CHECK_USER_CALL(glBindTransformFeedbackNV)
        UCT.glBindTransformFeedbackNV(param[0].uv32bit, param[1].uv32bit);
    CHECK_GL_CALL(glBindTransformFeedbackNV)
        JT.glBindTransformFeedbackNV(param[0].uv32bit, param[1].uv32bit);
}

void STUB_glBindVertexArray( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glBindVertexArray( GLuint )
    maxParam = 1;
    READ_ENUM_PARAM(0);
    TR.skipLine();
    CHECK_USER_CALL(glBindVertexArray)
        UCT.glBindVertexArray(param[0].uv32bit);
    CHECK_GL_CALL(glBindVertexArray)
        JT.glBindVertexArray(param[0].uv32bit);
}

void STUB_glBindVertexArrayAPPLE( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glBindVertexArrayAPPLE( GLuint )
    maxParam = 1;
    READ_ENUM_PARAM(0);
    TR.skipLine();
    CHECK_USER_CALL(glBindVertexArrayAPPLE)
        UCT.glBindVertexArrayAPPLE(param[0].uv32bit);
    CHECK_GL_CALL(glBindVertexArrayAPPLE)
        JT.glBindVertexArrayAPPLE(param[0].uv32bit);
}

void STUB_glBindVertexShaderEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glBindVertexShaderEXT( GLuint )
    maxParam = 1;
    READ_ENUM_PARAM(0);
    TR.skipLine();
    CHECK_USER_CALL(glBindVertexShaderEXT)
        UCT.glBindVertexShaderEXT(param[0].uv32bit);
    CHECK_GL_CALL(glBindVertexShaderEXT)
        JT.glBindVertexShaderEXT(param[0].uv32bit);
}

void STUB_glBinormal3bEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glBinormal3bEXT( GLbyte, GLbyte, GLbyte )
    maxParam = 3;
    READ_PARAM(v8bit,0);
    READ_PARAM(v8bit,1);
    READ_PARAM(v8bit,2);
    TR.skipLine();
    CHECK_USER_CALL(glBinormal3bEXT)
        UCT.glBinormal3bEXT(param[0].v8bit, param[1].v8bit, param[2].v8bit);
    CHECK_GL_CALL(glBinormal3bEXT)
        JT.glBinormal3bEXT(param[0].v8bit, param[1].v8bit, param[2].v8bit);
}

void STUB_glBinormal3bvEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glBinormal3bvEXT( const GLbyte * )
    maxParam = 1;
    char buffer0[16*4096];
    READ_ARRAY_PARAM( 0, buffer0, TraceReader::TEXT_BYTE);
    TR.skipLine();
    CHECK_USER_CALL(glBinormal3bvEXT)
        UCT.glBinormal3bvEXT((const GLbyte *)param[0].ptr);
    CHECK_GL_CALL(glBinormal3bvEXT)
        JT.glBinormal3bvEXT((const GLbyte *)param[0].ptr);
}

void STUB_glBinormal3dEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glBinormal3dEXT( GLdouble, GLdouble, GLdouble )
    maxParam = 3;
    READ_DOUBLE_PARAM(0);
    READ_DOUBLE_PARAM(1);
    READ_DOUBLE_PARAM(2);
    TR.skipLine();
    CHECK_USER_CALL(glBinormal3dEXT)
        UCT.glBinormal3dEXT(param[0].fv64bit, param[1].fv64bit, param[2].fv64bit);
    CHECK_GL_CALL(glBinormal3dEXT)
        JT.glBinormal3dEXT(param[0].fv64bit, param[1].fv64bit, param[2].fv64bit);
}

void STUB_glBinormal3dvEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glBinormal3dvEXT( const GLdouble * )
    maxParam = 1;
    char buffer0[16*4096];
    READ_ARRAY_PARAM( 0, buffer0, TraceReader::TEXT_DOUBLE);
    TR.skipLine();
    CHECK_USER_CALL(glBinormal3dvEXT)
        UCT.glBinormal3dvEXT((const GLdouble *)param[0].ptr);
    CHECK_GL_CALL(glBinormal3dvEXT)
        JT.glBinormal3dvEXT((const GLdouble *)param[0].ptr);
}

void STUB_glBinormal3fEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glBinormal3fEXT( GLfloat, GLfloat, GLfloat )
    maxParam = 3;
    READ_PARAM(fv32bit,0);
    READ_PARAM(fv32bit,1);
    READ_PARAM(fv32bit,2);
    TR.skipLine();
    CHECK_USER_CALL(glBinormal3fEXT)
        UCT.glBinormal3fEXT(param[0].fv32bit, param[1].fv32bit, param[2].fv32bit);
    CHECK_GL_CALL(glBinormal3fEXT)
        JT.glBinormal3fEXT(param[0].fv32bit, param[1].fv32bit, param[2].fv32bit);
}

void STUB_glBinormal3fvEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glBinormal3fvEXT( const GLfloat * )
    maxParam = 1;
    char buffer0[16*4096];
    READ_ARRAY_PARAM( 0, buffer0, TraceReader::TEXT_FLOAT);
    TR.skipLine();
    CHECK_USER_CALL(glBinormal3fvEXT)
        UCT.glBinormal3fvEXT((const GLfloat *)param[0].ptr);
    CHECK_GL_CALL(glBinormal3fvEXT)
        JT.glBinormal3fvEXT((const GLfloat *)param[0].ptr);
}

void STUB_glBinormal3iEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glBinormal3iEXT( GLint, GLint, GLint )
    maxParam = 3;
    READ_PARAM(v32bit,0);
    READ_PARAM(v32bit,1);
    READ_PARAM(v32bit,2);
    TR.skipLine();
    CHECK_USER_CALL(glBinormal3iEXT)
        UCT.glBinormal3iEXT(param[0].v32bit, param[1].v32bit, param[2].v32bit);
    CHECK_GL_CALL(glBinormal3iEXT)
        JT.glBinormal3iEXT(param[0].v32bit, param[1].v32bit, param[2].v32bit);
}

void STUB_glBinormal3ivEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glBinormal3ivEXT( const GLint * )
    maxParam = 1;
    char buffer0[16*4096];
    READ_ARRAY_PARAM( 0, buffer0, TraceReader::TEXT_INT);
    TR.skipLine();
    CHECK_USER_CALL(glBinormal3ivEXT)
        UCT.glBinormal3ivEXT((const GLint *)param[0].ptr);
    CHECK_GL_CALL(glBinormal3ivEXT)
        JT.glBinormal3ivEXT((const GLint *)param[0].ptr);
}

void STUB_glBinormal3sEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glBinormal3sEXT( GLshort, GLshort, GLshort )
    maxParam = 3;
    READ_PARAM(v16bit,0);
    READ_PARAM(v16bit,1);
    READ_PARAM(v16bit,2);
    TR.skipLine();
    CHECK_USER_CALL(glBinormal3sEXT)
        UCT.glBinormal3sEXT(param[0].v16bit, param[1].v16bit, param[2].v16bit);
    CHECK_GL_CALL(glBinormal3sEXT)
        JT.glBinormal3sEXT(param[0].v16bit, param[1].v16bit, param[2].v16bit);
}

void STUB_glBinormal3svEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glBinormal3svEXT( const GLshort * )
    maxParam = 1;
    char buffer0[16*4096];
    READ_ARRAY_PARAM( 0, buffer0, TraceReader::TEXT_SHORT);
    TR.skipLine();
    CHECK_USER_CALL(glBinormal3svEXT)
        UCT.glBinormal3svEXT((const GLshort *)param[0].ptr);
    CHECK_GL_CALL(glBinormal3svEXT)
        JT.glBinormal3svEXT((const GLshort *)param[0].ptr);
}

void STUB_glBinormalPointerEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glBinormalPointerEXT( GLenum, GLsizei, const GLvoid * )
    maxParam = 3;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_PARAM(v32bit,1);
    READ_ARRAY_PARAM( 2, buffer0, TraceReader::TEXT_IGNORE);
    TR.skipLine();
    CHECK_USER_CALL(glBinormalPointerEXT)
        UCT.glBinormalPointerEXT(param[0].uv32bit, param[1].v32bit, (const GLvoid *)param[2].ptr);
    CHECK_GL_CALL(glBinormalPointerEXT)
        JT.glBinormalPointerEXT(param[0].uv32bit, param[1].v32bit, (const GLvoid *)param[2].ptr);
}

void STUB_glBitmap( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glBitmap( GLsizei width, GLsizei height, GLfloat xorig, GLfloat yorig, GLfloat xmove, GLfloat ymove, const GLubyte *bitmap )
    maxParam = 7;
    char buffer0[16*4096];
    READ_PARAM(v32bit,0);
    READ_PARAM(v32bit,1);
    READ_PARAM(fv32bit,2);
    READ_PARAM(fv32bit,3);
    READ_PARAM(fv32bit,4);
    READ_PARAM(fv32bit,5);
    READ_ARRAY_PARAM( 6, buffer0, TraceReader::TEXT_BYTE);
    TR.skipLine();
    CHECK_USER_CALL(glBitmap)
        UCT.glBitmap(param[0].v32bit, param[1].v32bit, param[2].fv32bit, param[3].fv32bit, param[4].fv32bit, param[5].fv32bit, (const GLubyte *)param[6].ptr);
    CHECK_GL_CALL(glBitmap)
        JT.glBitmap(param[0].v32bit, param[1].v32bit, param[2].fv32bit, param[3].fv32bit, param[4].fv32bit, param[5].fv32bit, (const GLubyte *)param[6].ptr);
}

void STUB_glBlendColor( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glBlendColor( GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha )
    maxParam = 4;
    READ_PARAM(fv32bit,0);
    READ_PARAM(fv32bit,1);
    READ_PARAM(fv32bit,2);
    READ_PARAM(fv32bit,3);
    TR.skipLine();
    CHECK_USER_CALL(glBlendColor)
        UCT.glBlendColor(param[0].fv32bit, param[1].fv32bit, param[2].fv32bit, param[3].fv32bit);
    CHECK_GL_CALL(glBlendColor)
        JT.glBlendColor(param[0].fv32bit, param[1].fv32bit, param[2].fv32bit, param[3].fv32bit);
}

void STUB_glBlendColorEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glBlendColorEXT( GLclampf, GLclampf, GLclampf, GLclampf )
    maxParam = 4;
    READ_PARAM(fv32bit,0);
    READ_PARAM(fv32bit,1);
    READ_PARAM(fv32bit,2);
    READ_PARAM(fv32bit,3);
    TR.skipLine();
    CHECK_USER_CALL(glBlendColorEXT)
        UCT.glBlendColorEXT(param[0].fv32bit, param[1].fv32bit, param[2].fv32bit, param[3].fv32bit);
    CHECK_GL_CALL(glBlendColorEXT)
        JT.glBlendColorEXT(param[0].fv32bit, param[1].fv32bit, param[2].fv32bit, param[3].fv32bit);
}

void STUB_glBlendEquation( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glBlendEquation( GLenum mode )
    maxParam = 1;
    READ_ENUM_PARAM(0);
    TR.skipLine();
    CHECK_USER_CALL(glBlendEquation)
        UCT.glBlendEquation(param[0].uv32bit);
    CHECK_GL_CALL(glBlendEquation)
        JT.glBlendEquation(param[0].uv32bit);
}

void STUB_glBlendEquationEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glBlendEquationEXT( GLenum )
    maxParam = 1;
    READ_ENUM_PARAM(0);
    TR.skipLine();
    CHECK_USER_CALL(glBlendEquationEXT)
        UCT.glBlendEquationEXT(param[0].uv32bit);
    CHECK_GL_CALL(glBlendEquationEXT)
        JT.glBlendEquationEXT(param[0].uv32bit);
}

void STUB_glBlendEquationSeparate( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glBlendEquationSeparate( GLenum, GLenum )
    maxParam = 2;
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    TR.skipLine();
    CHECK_USER_CALL(glBlendEquationSeparate)
        UCT.glBlendEquationSeparate(param[0].uv32bit, param[1].uv32bit);
    CHECK_GL_CALL(glBlendEquationSeparate)
        JT.glBlendEquationSeparate(param[0].uv32bit, param[1].uv32bit);
}

void STUB_glBlendEquationSeparateATI( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glBlendEquationSeparateATI( GLenum modeRGB, GLenum modeA )
    maxParam = 2;
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    TR.skipLine();
    CHECK_USER_CALL(glBlendEquationSeparateATI)
        UCT.glBlendEquationSeparateATI(param[0].uv32bit, param[1].uv32bit);
    CHECK_GL_CALL(glBlendEquationSeparateATI)
        JT.glBlendEquationSeparateATI(param[0].uv32bit, param[1].uv32bit);
}

void STUB_glBlendEquationSeparateEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glBlendEquationSeparateEXT( GLenum, GLenum )
    maxParam = 2;
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    TR.skipLine();
    CHECK_USER_CALL(glBlendEquationSeparateEXT)
        UCT.glBlendEquationSeparateEXT(param[0].uv32bit, param[1].uv32bit);
    CHECK_GL_CALL(glBlendEquationSeparateEXT)
        JT.glBlendEquationSeparateEXT(param[0].uv32bit, param[1].uv32bit);
}

void STUB_glBlendFunc( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glBlendFunc( GLenum sfactor, GLenum dfactor )
    maxParam = 2;
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    TR.skipLine();
    CHECK_USER_CALL(glBlendFunc)
        UCT.glBlendFunc(param[0].uv32bit, param[1].uv32bit);
    CHECK_GL_CALL(glBlendFunc)
        JT.glBlendFunc(param[0].uv32bit, param[1].uv32bit);
}

void STUB_glBlendFuncSeparate( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glBlendFuncSeparate( GLenum, GLenum, GLenum, GLenum )
    maxParam = 4;
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_ENUM_PARAM(2);
    READ_ENUM_PARAM(3);
    TR.skipLine();
    CHECK_USER_CALL(glBlendFuncSeparate)
        UCT.glBlendFuncSeparate(param[0].uv32bit, param[1].uv32bit, param[2].uv32bit, param[3].uv32bit);
    CHECK_GL_CALL(glBlendFuncSeparate)
        JT.glBlendFuncSeparate(param[0].uv32bit, param[1].uv32bit, param[2].uv32bit, param[3].uv32bit);
}

void STUB_glBlendFuncSeparateEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glBlendFuncSeparateEXT( GLenum, GLenum, GLenum, GLenum )
    maxParam = 4;
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_ENUM_PARAM(2);
    READ_ENUM_PARAM(3);
    TR.skipLine();
    CHECK_USER_CALL(glBlendFuncSeparateEXT)
        UCT.glBlendFuncSeparateEXT(param[0].uv32bit, param[1].uv32bit, param[2].uv32bit, param[3].uv32bit);
    CHECK_GL_CALL(glBlendFuncSeparateEXT)
        JT.glBlendFuncSeparateEXT(param[0].uv32bit, param[1].uv32bit, param[2].uv32bit, param[3].uv32bit);
}

void STUB_glBlendFuncSeparateINGR( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glBlendFuncSeparateINGR( GLenum, GLenum, GLenum, GLenum )
    maxParam = 4;
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_ENUM_PARAM(2);
    READ_ENUM_PARAM(3);
    TR.skipLine();
    CHECK_USER_CALL(glBlendFuncSeparateINGR)
        UCT.glBlendFuncSeparateINGR(param[0].uv32bit, param[1].uv32bit, param[2].uv32bit, param[3].uv32bit);
    CHECK_GL_CALL(glBlendFuncSeparateINGR)
        JT.glBlendFuncSeparateINGR(param[0].uv32bit, param[1].uv32bit, param[2].uv32bit, param[3].uv32bit);
}

void STUB_glBlitFramebuffer( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glBlitFramebuffer( GLint, GLint, GLint, GLint, GLint, GLint, GLint, GLint, GLbitfield, GLenum )
    maxParam = 10;
    READ_PARAM(v32bit,0);
    READ_PARAM(v32bit,1);
    READ_PARAM(v32bit,2);
    READ_PARAM(v32bit,3);
    READ_PARAM(v32bit,4);
    READ_PARAM(v32bit,5);
    READ_PARAM(v32bit,6);
    READ_PARAM(v32bit,7);
    READ_ORING_PARAM(8);
    READ_ENUM_PARAM(9);
    TR.skipLine();
    CHECK_USER_CALL(glBlitFramebuffer)
        UCT.glBlitFramebuffer(param[0].v32bit, param[1].v32bit, param[2].v32bit, param[3].v32bit, param[4].v32bit, param[5].v32bit, param[6].v32bit, param[7].v32bit, param[8].uv32bit, param[9].uv32bit);
    CHECK_GL_CALL(glBlitFramebuffer)
        JT.glBlitFramebuffer(param[0].v32bit, param[1].v32bit, param[2].v32bit, param[3].v32bit, param[4].v32bit, param[5].v32bit, param[6].v32bit, param[7].v32bit, param[8].uv32bit, param[9].uv32bit);
}

void STUB_glBlitFramebufferEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glBlitFramebufferEXT( GLint, GLint, GLint, GLint, GLint, GLint, GLint, GLint, GLbitfield, GLenum )
    maxParam = 10;
    READ_PARAM(v32bit,0);
    READ_PARAM(v32bit,1);
    READ_PARAM(v32bit,2);
    READ_PARAM(v32bit,3);
    READ_PARAM(v32bit,4);
    READ_PARAM(v32bit,5);
    READ_PARAM(v32bit,6);
    READ_PARAM(v32bit,7);
    READ_ORING_PARAM(8);
    READ_ENUM_PARAM(9);
    TR.skipLine();
    CHECK_USER_CALL(glBlitFramebufferEXT)
        UCT.glBlitFramebufferEXT(param[0].v32bit, param[1].v32bit, param[2].v32bit, param[3].v32bit, param[4].v32bit, param[5].v32bit, param[6].v32bit, param[7].v32bit, param[8].uv32bit, param[9].uv32bit);
    CHECK_GL_CALL(glBlitFramebufferEXT)
        JT.glBlitFramebufferEXT(param[0].v32bit, param[1].v32bit, param[2].v32bit, param[3].v32bit, param[4].v32bit, param[5].v32bit, param[6].v32bit, param[7].v32bit, param[8].uv32bit, param[9].uv32bit);
}

void STUB_glBufferData( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glBufferData( GLenum, GLsizeiptr, const GLvoid *, GLenum )
    maxParam = 4;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_PARAM(v32bit,1);
    READ_ARRAY_PARAM( 2, buffer0, TraceReader::TEXT_IGNORE);
    READ_ENUM_PARAM(3);
    TR.skipLine();
    CHECK_USER_CALL(glBufferData)
        UCT.glBufferData(param[0].uv32bit, param[1].v32bit, (const GLvoid *)param[2].ptr, param[3].uv32bit);
    CHECK_GL_CALL(glBufferData)
        JT.glBufferData(param[0].uv32bit, param[1].v32bit, (const GLvoid *)param[2].ptr, param[3].uv32bit);
}

void STUB_glBufferDataARB( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glBufferDataARB( GLenum, GLsizeiptrARB, const GLvoid *, GLenum )
    maxParam = 4;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_PARAM(v32bit,1);
    READ_ARRAY_PARAM( 2, buffer0, TraceReader::TEXT_IGNORE);
    READ_ENUM_PARAM(3);
    TR.skipLine();
    CHECK_USER_CALL(glBufferDataARB)
        UCT.glBufferDataARB(param[0].uv32bit, param[1].v32bit, (const GLvoid *)param[2].ptr, param[3].uv32bit);
    CHECK_GL_CALL(glBufferDataARB)
        JT.glBufferDataARB(param[0].uv32bit, param[1].v32bit, (const GLvoid *)param[2].ptr, param[3].uv32bit);
}

void STUB_glBufferParameteriAPPLE( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glBufferParameteriAPPLE( GLenum, GLenum, GLint )
    maxParam = 3;
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_PARAM(v32bit,2);
    TR.skipLine();
    CHECK_USER_CALL(glBufferParameteriAPPLE)
        UCT.glBufferParameteriAPPLE(param[0].uv32bit, param[1].uv32bit, param[2].v32bit);
    CHECK_GL_CALL(glBufferParameteriAPPLE)
        JT.glBufferParameteriAPPLE(param[0].uv32bit, param[1].uv32bit, param[2].v32bit);
}

void STUB_glBufferSubData( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glBufferSubData( GLenum, GLintptr, GLsizeiptr, const GLvoid * )
    maxParam = 4;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_PARAM(v32bit,1);
    READ_PARAM(v32bit,2);
    READ_ARRAY_PARAM( 3, buffer0, TraceReader::TEXT_IGNORE);
    TR.skipLine();
    CHECK_USER_CALL(glBufferSubData)
        UCT.glBufferSubData(param[0].uv32bit, param[1].v32bit, param[2].v32bit, (const GLvoid *)param[3].ptr);
    CHECK_GL_CALL(glBufferSubData)
        JT.glBufferSubData(param[0].uv32bit, param[1].v32bit, param[2].v32bit, (const GLvoid *)param[3].ptr);
}

void STUB_glBufferSubDataARB( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glBufferSubDataARB( GLenum, GLintptrARB, GLsizeiptrARB, const GLvoid * )
    maxParam = 4;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_PARAM(v32bit,1);
    READ_PARAM(v32bit,2);
    READ_ARRAY_PARAM( 3, buffer0, TraceReader::TEXT_IGNORE);
    TR.skipLine();
    CHECK_USER_CALL(glBufferSubDataARB)
        UCT.glBufferSubDataARB(param[0].uv32bit, param[1].v32bit, param[2].v32bit, (const GLvoid *)param[3].ptr);
    CHECK_GL_CALL(glBufferSubDataARB)
        JT.glBufferSubDataARB(param[0].uv32bit, param[1].v32bit, param[2].v32bit, (const GLvoid *)param[3].ptr);
}

void STUB_glCallList( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glCallList( GLuint list )
    maxParam = 1;
    READ_ENUM_PARAM(0);
    TR.skipLine();
    CHECK_USER_CALL(glCallList)
        UCT.glCallList(param[0].uv32bit);
    CHECK_GL_CALL(glCallList)
        JT.glCallList(param[0].uv32bit);
}

void STUB_glCallLists( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glCallLists( GLsizei n, GLenum type, const GLvoid *lists )
    maxParam = 3;
    char buffer0[16*4096];
    READ_PARAM(v32bit,0);
    READ_ENUM_PARAM(1);
    READ_ARRAY_PARAM( 2, buffer0, TraceReader::TEXT_IGNORE);
    TR.skipLine();
    CHECK_USER_CALL(glCallLists)
        UCT.glCallLists(param[0].v32bit, param[1].uv32bit, (const GLvoid *)param[2].ptr);
    CHECK_GL_CALL(glCallLists)
        JT.glCallLists(param[0].v32bit, param[1].uv32bit, (const GLvoid *)param[2].ptr);
}

void STUB_glCheckFramebufferStatus( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // GLenum glCheckFramebufferStatus( GLenum )
    maxParam = 1;
    READ_ENUM_PARAM(0);
    TR.skipResult();
    TR.skipLine();
    CHECK_USER_CALL(glCheckFramebufferStatus)
        UCT.glCheckFramebufferStatus(param[0].uv32bit);
    CHECK_GL_CALL(glCheckFramebufferStatus)
        JT.glCheckFramebufferStatus(param[0].uv32bit);
}

void STUB_glCheckFramebufferStatusEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // GLenum glCheckFramebufferStatusEXT( GLenum )
    maxParam = 1;
    READ_ENUM_PARAM(0);
    TR.skipResult();
    TR.skipLine();
    CHECK_USER_CALL(glCheckFramebufferStatusEXT)
        UCT.glCheckFramebufferStatusEXT(param[0].uv32bit);
    CHECK_GL_CALL(glCheckFramebufferStatusEXT)
        JT.glCheckFramebufferStatusEXT(param[0].uv32bit);
}

void STUB_glCheckNamedFramebufferStatusEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // GLenum glCheckNamedFramebufferStatusEXT( GLuint, GLenum )
    maxParam = 2;
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    TR.skipResult();
    TR.skipLine();
    CHECK_USER_CALL(glCheckNamedFramebufferStatusEXT)
        UCT.glCheckNamedFramebufferStatusEXT(param[0].uv32bit, param[1].uv32bit);
    CHECK_GL_CALL(glCheckNamedFramebufferStatusEXT)
        JT.glCheckNamedFramebufferStatusEXT(param[0].uv32bit, param[1].uv32bit);
}

void STUB_glClampColor( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glClampColor( GLenum, GLenum )
    maxParam = 2;
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    TR.skipLine();
    CHECK_USER_CALL(glClampColor)
        UCT.glClampColor(param[0].uv32bit, param[1].uv32bit);
    CHECK_GL_CALL(glClampColor)
        JT.glClampColor(param[0].uv32bit, param[1].uv32bit);
}

void STUB_glClampColorARB( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glClampColorARB( GLenum, GLenum )
    maxParam = 2;
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    TR.skipLine();
    CHECK_USER_CALL(glClampColorARB)
        UCT.glClampColorARB(param[0].uv32bit, param[1].uv32bit);
    CHECK_GL_CALL(glClampColorARB)
        JT.glClampColorARB(param[0].uv32bit, param[1].uv32bit);
}

void STUB_glClear( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glClear( GLbitfield mask )
    maxParam = 1;
    READ_ORING_PARAM(0);
    TR.skipLine();
    CHECK_USER_CALL(glClear)
        UCT.glClear(param[0].uv32bit);
    CHECK_GL_CALL(glClear)
        JT.glClear(param[0].uv32bit);
}

void STUB_glClearAccum( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glClearAccum( GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha )
    maxParam = 4;
    READ_PARAM(fv32bit,0);
    READ_PARAM(fv32bit,1);
    READ_PARAM(fv32bit,2);
    READ_PARAM(fv32bit,3);
    TR.skipLine();
    CHECK_USER_CALL(glClearAccum)
        UCT.glClearAccum(param[0].fv32bit, param[1].fv32bit, param[2].fv32bit, param[3].fv32bit);
    CHECK_GL_CALL(glClearAccum)
        JT.glClearAccum(param[0].fv32bit, param[1].fv32bit, param[2].fv32bit, param[3].fv32bit);
}

void STUB_glClearBufferfi( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glClearBufferfi( GLenum, GLint, GLfloat, GLint )
    maxParam = 4;
    READ_ENUM_PARAM(0);
    READ_PARAM(v32bit,1);
    READ_PARAM(fv32bit,2);
    READ_PARAM(v32bit,3);
    TR.skipLine();
    CHECK_USER_CALL(glClearBufferfi)
        UCT.glClearBufferfi(param[0].uv32bit, param[1].v32bit, param[2].fv32bit, param[3].v32bit);
    CHECK_GL_CALL(glClearBufferfi)
        JT.glClearBufferfi(param[0].uv32bit, param[1].v32bit, param[2].fv32bit, param[3].v32bit);
}

void STUB_glClearBufferfv( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glClearBufferfv( GLenum, GLint, const GLfloat * )
    maxParam = 3;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_PARAM(v32bit,1);
    READ_ARRAY_PARAM( 2, buffer0, TraceReader::TEXT_FLOAT);
    TR.skipLine();
    CHECK_USER_CALL(glClearBufferfv)
        UCT.glClearBufferfv(param[0].uv32bit, param[1].v32bit, (const GLfloat *)param[2].ptr);
    CHECK_GL_CALL(glClearBufferfv)
        JT.glClearBufferfv(param[0].uv32bit, param[1].v32bit, (const GLfloat *)param[2].ptr);
}

void STUB_glClearBufferiv( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glClearBufferiv( GLenum, GLint, const GLint * )
    maxParam = 3;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_PARAM(v32bit,1);
    READ_ARRAY_PARAM( 2, buffer0, TraceReader::TEXT_INT);
    TR.skipLine();
    CHECK_USER_CALL(glClearBufferiv)
        UCT.glClearBufferiv(param[0].uv32bit, param[1].v32bit, (const GLint *)param[2].ptr);
    CHECK_GL_CALL(glClearBufferiv)
        JT.glClearBufferiv(param[0].uv32bit, param[1].v32bit, (const GLint *)param[2].ptr);
}

void STUB_glClearBufferuiv( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glClearBufferuiv( GLenum, GLint, const GLuint * )
    maxParam = 3;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_PARAM(v32bit,1);
    READ_ARRAY_PARAM( 2, buffer0, TraceReader::TEXT_INT);
    TR.skipLine();
    CHECK_USER_CALL(glClearBufferuiv)
        UCT.glClearBufferuiv(param[0].uv32bit, param[1].v32bit, (const GLuint *)param[2].ptr);
    CHECK_GL_CALL(glClearBufferuiv)
        JT.glClearBufferuiv(param[0].uv32bit, param[1].v32bit, (const GLuint *)param[2].ptr);
}

void STUB_glClearColor( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glClearColor( GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha )
    maxParam = 4;
    READ_PARAM(fv32bit,0);
    READ_PARAM(fv32bit,1);
    READ_PARAM(fv32bit,2);
    READ_PARAM(fv32bit,3);
    TR.skipLine();
    CHECK_USER_CALL(glClearColor)
        UCT.glClearColor(param[0].fv32bit, param[1].fv32bit, param[2].fv32bit, param[3].fv32bit);
    CHECK_GL_CALL(glClearColor)
        JT.glClearColor(param[0].fv32bit, param[1].fv32bit, param[2].fv32bit, param[3].fv32bit);
}

void STUB_glClearColorIiEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glClearColorIiEXT( GLint, GLint, GLint, GLint )
    maxParam = 4;
    READ_PARAM(v32bit,0);
    READ_PARAM(v32bit,1);
    READ_PARAM(v32bit,2);
    READ_PARAM(v32bit,3);
    TR.skipLine();
    CHECK_USER_CALL(glClearColorIiEXT)
        UCT.glClearColorIiEXT(param[0].v32bit, param[1].v32bit, param[2].v32bit, param[3].v32bit);
    CHECK_GL_CALL(glClearColorIiEXT)
        JT.glClearColorIiEXT(param[0].v32bit, param[1].v32bit, param[2].v32bit, param[3].v32bit);
}

void STUB_glClearColorIuiEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glClearColorIuiEXT( GLuint, GLuint, GLuint, GLuint )
    maxParam = 4;
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_ENUM_PARAM(2);
    READ_ENUM_PARAM(3);
    TR.skipLine();
    CHECK_USER_CALL(glClearColorIuiEXT)
        UCT.glClearColorIuiEXT(param[0].uv32bit, param[1].uv32bit, param[2].uv32bit, param[3].uv32bit);
    CHECK_GL_CALL(glClearColorIuiEXT)
        JT.glClearColorIuiEXT(param[0].uv32bit, param[1].uv32bit, param[2].uv32bit, param[3].uv32bit);
}

void STUB_glClearDepth( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glClearDepth( GLclampd depth )
    maxParam = 1;
    READ_DOUBLE_PARAM(0);
    TR.skipLine();
    CHECK_USER_CALL(glClearDepth)
        UCT.glClearDepth(param[0].fv64bit);
    CHECK_GL_CALL(glClearDepth)
        JT.glClearDepth(param[0].fv64bit);
}

void STUB_glClearDepthdNV( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glClearDepthdNV( GLdouble )
    maxParam = 1;
    READ_DOUBLE_PARAM(0);
    TR.skipLine();
    CHECK_USER_CALL(glClearDepthdNV)
        UCT.glClearDepthdNV(param[0].fv64bit);
    CHECK_GL_CALL(glClearDepthdNV)
        JT.glClearDepthdNV(param[0].fv64bit);
}

void STUB_glClearIndex( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glClearIndex( GLfloat c )
    maxParam = 1;
    READ_PARAM(fv32bit,0);
    TR.skipLine();
    CHECK_USER_CALL(glClearIndex)
        UCT.glClearIndex(param[0].fv32bit);
    CHECK_GL_CALL(glClearIndex)
        JT.glClearIndex(param[0].fv32bit);
}

void STUB_glClearStencil( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glClearStencil( GLint s )
    maxParam = 1;
    READ_PARAM(v32bit,0);
    TR.skipLine();
    CHECK_USER_CALL(glClearStencil)
        UCT.glClearStencil(param[0].v32bit);
    CHECK_GL_CALL(glClearStencil)
        JT.glClearStencil(param[0].v32bit);
}

void STUB_glClientActiveTexture( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glClientActiveTexture( GLenum texture )
    maxParam = 1;
    READ_ENUM_PARAM(0);
    TR.skipLine();
    CHECK_USER_CALL(glClientActiveTexture)
        UCT.glClientActiveTexture(param[0].uv32bit);
    CHECK_GL_CALL(glClientActiveTexture)
        JT.glClientActiveTexture(param[0].uv32bit);
}

void STUB_glClientActiveTextureARB( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glClientActiveTextureARB( GLenum texture )
    maxParam = 1;
    READ_ENUM_PARAM(0);
    TR.skipLine();
    CHECK_USER_CALL(glClientActiveTextureARB)
        UCT.glClientActiveTextureARB(param[0].uv32bit);
    CHECK_GL_CALL(glClientActiveTextureARB)
        JT.glClientActiveTextureARB(param[0].uv32bit);
}

void STUB_glClientActiveVertexStreamATI( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glClientActiveVertexStreamATI( GLenum )
    maxParam = 1;
    READ_ENUM_PARAM(0);
    TR.skipLine();
    CHECK_USER_CALL(glClientActiveVertexStreamATI)
        UCT.glClientActiveVertexStreamATI(param[0].uv32bit);
    CHECK_GL_CALL(glClientActiveVertexStreamATI)
        JT.glClientActiveVertexStreamATI(param[0].uv32bit);
}

void STUB_glClientAttribDefaultEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glClientAttribDefaultEXT( GLbitfield )
    maxParam = 1;
    READ_ORING_PARAM(0);
    TR.skipLine();
    CHECK_USER_CALL(glClientAttribDefaultEXT)
        UCT.glClientAttribDefaultEXT(param[0].uv32bit);
    CHECK_GL_CALL(glClientAttribDefaultEXT)
        JT.glClientAttribDefaultEXT(param[0].uv32bit);
}

void STUB_glClipPlane( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glClipPlane( GLenum plane, const GLdouble *equation )
    maxParam = 2;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ARRAY_PARAM( 1, buffer0, TraceReader::TEXT_DOUBLE);
    TR.skipLine();
    CHECK_USER_CALL(glClipPlane)
        UCT.glClipPlane(param[0].uv32bit, (const GLdouble *)param[1].ptr);
    CHECK_GL_CALL(glClipPlane)
        JT.glClipPlane(param[0].uv32bit, (const GLdouble *)param[1].ptr);
}

void STUB_glColor3b( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glColor3b( GLbyte red, GLbyte green, GLbyte blue )
    maxParam = 3;
    READ_PARAM(v8bit,0);
    READ_PARAM(v8bit,1);
    READ_PARAM(v8bit,2);
    TR.skipLine();
    CHECK_USER_CALL(glColor3b)
        UCT.glColor3b(param[0].v8bit, param[1].v8bit, param[2].v8bit);
    CHECK_GL_CALL(glColor3b)
        JT.glColor3b(param[0].v8bit, param[1].v8bit, param[2].v8bit);
}

void STUB_glColor3bv( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glColor3bv( const GLbyte *v )
    maxParam = 1;
    char buffer0[16*4096];
    READ_ARRAY_PARAM( 0, buffer0, TraceReader::TEXT_BYTE);
    TR.skipLine();
    CHECK_USER_CALL(glColor3bv)
        UCT.glColor3bv((const GLbyte *)param[0].ptr);
    CHECK_GL_CALL(glColor3bv)
        JT.glColor3bv((const GLbyte *)param[0].ptr);
}

void STUB_glColor3d( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glColor3d( GLdouble red, GLdouble green, GLdouble blue )
    maxParam = 3;
    READ_DOUBLE_PARAM(0);
    READ_DOUBLE_PARAM(1);
    READ_DOUBLE_PARAM(2);
    TR.skipLine();
    CHECK_USER_CALL(glColor3d)
        UCT.glColor3d(param[0].fv64bit, param[1].fv64bit, param[2].fv64bit);
    CHECK_GL_CALL(glColor3d)
        JT.glColor3d(param[0].fv64bit, param[1].fv64bit, param[2].fv64bit);
}

void STUB_glColor3dv( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glColor3dv( const GLdouble *v )
    maxParam = 1;
    char buffer0[16*4096];
    READ_ARRAY_PARAM( 0, buffer0, TraceReader::TEXT_DOUBLE);
    TR.skipLine();
    CHECK_USER_CALL(glColor3dv)
        UCT.glColor3dv((const GLdouble *)param[0].ptr);
    CHECK_GL_CALL(glColor3dv)
        JT.glColor3dv((const GLdouble *)param[0].ptr);
}

void STUB_glColor3f( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glColor3f( GLfloat red, GLfloat green, GLfloat blue )
    maxParam = 3;
    READ_PARAM(fv32bit,0);
    READ_PARAM(fv32bit,1);
    READ_PARAM(fv32bit,2);
    TR.skipLine();
    CHECK_USER_CALL(glColor3f)
        UCT.glColor3f(param[0].fv32bit, param[1].fv32bit, param[2].fv32bit);
    CHECK_GL_CALL(glColor3f)
        JT.glColor3f(param[0].fv32bit, param[1].fv32bit, param[2].fv32bit);
}

void STUB_glColor3fv( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glColor3fv( const GLfloat *v )
    maxParam = 1;
    char buffer0[16*4096];
    READ_ARRAY_PARAM( 0, buffer0, TraceReader::TEXT_FLOAT);
    TR.skipLine();
    CHECK_USER_CALL(glColor3fv)
        UCT.glColor3fv((const GLfloat *)param[0].ptr);
    CHECK_GL_CALL(glColor3fv)
        JT.glColor3fv((const GLfloat *)param[0].ptr);
}

void STUB_glColor3hNV( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glColor3hNV( GLhalfNV, GLhalfNV, GLhalfNV )
    // Call not playable
    TR.skipCall();
}

void STUB_glColor3hvNV( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glColor3hvNV( const GLhalfNV * )
    // Call not playable
    TR.skipCall();
}

void STUB_glColor3i( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glColor3i( GLint red, GLint green, GLint blue )
    maxParam = 3;
    READ_PARAM(v32bit,0);
    READ_PARAM(v32bit,1);
    READ_PARAM(v32bit,2);
    TR.skipLine();
    CHECK_USER_CALL(glColor3i)
        UCT.glColor3i(param[0].v32bit, param[1].v32bit, param[2].v32bit);
    CHECK_GL_CALL(glColor3i)
        JT.glColor3i(param[0].v32bit, param[1].v32bit, param[2].v32bit);
}

void STUB_glColor3iv( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glColor3iv( const GLint *v )
    maxParam = 1;
    char buffer0[16*4096];
    READ_ARRAY_PARAM( 0, buffer0, TraceReader::TEXT_INT);
    TR.skipLine();
    CHECK_USER_CALL(glColor3iv)
        UCT.glColor3iv((const GLint *)param[0].ptr);
    CHECK_GL_CALL(glColor3iv)
        JT.glColor3iv((const GLint *)param[0].ptr);
}

void STUB_glColor3s( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glColor3s( GLshort red, GLshort green, GLshort blue )
    maxParam = 3;
    READ_PARAM(v16bit,0);
    READ_PARAM(v16bit,1);
    READ_PARAM(v16bit,2);
    TR.skipLine();
    CHECK_USER_CALL(glColor3s)
        UCT.glColor3s(param[0].v16bit, param[1].v16bit, param[2].v16bit);
    CHECK_GL_CALL(glColor3s)
        JT.glColor3s(param[0].v16bit, param[1].v16bit, param[2].v16bit);
}

void STUB_glColor3sv( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glColor3sv( const GLshort *v )
    maxParam = 1;
    char buffer0[16*4096];
    READ_ARRAY_PARAM( 0, buffer0, TraceReader::TEXT_SHORT);
    TR.skipLine();
    CHECK_USER_CALL(glColor3sv)
        UCT.glColor3sv((const GLshort *)param[0].ptr);
    CHECK_GL_CALL(glColor3sv)
        JT.glColor3sv((const GLshort *)param[0].ptr);
}

void STUB_glColor3ub( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glColor3ub( GLubyte red, GLubyte green, GLubyte blue )
    maxParam = 3;
    READ_PARAM(uv8bit,0);
    READ_PARAM(uv8bit,1);
    READ_PARAM(uv8bit,2);
    TR.skipLine();
    CHECK_USER_CALL(glColor3ub)
        UCT.glColor3ub(param[0].uv8bit, param[1].uv8bit, param[2].uv8bit);
    CHECK_GL_CALL(glColor3ub)
        JT.glColor3ub(param[0].uv8bit, param[1].uv8bit, param[2].uv8bit);
}

void STUB_glColor3ubv( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glColor3ubv( const GLubyte *v )
    maxParam = 1;
    char buffer0[16*4096];
    READ_ARRAY_PARAM( 0, buffer0, TraceReader::TEXT_BYTE);
    TR.skipLine();
    CHECK_USER_CALL(glColor3ubv)
        UCT.glColor3ubv((const GLubyte *)param[0].ptr);
    CHECK_GL_CALL(glColor3ubv)
        JT.glColor3ubv((const GLubyte *)param[0].ptr);
}

void STUB_glColor3ui( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glColor3ui( GLuint red, GLuint green, GLuint blue )
    maxParam = 3;
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_ENUM_PARAM(2);
    TR.skipLine();
    CHECK_USER_CALL(glColor3ui)
        UCT.glColor3ui(param[0].uv32bit, param[1].uv32bit, param[2].uv32bit);
    CHECK_GL_CALL(glColor3ui)
        JT.glColor3ui(param[0].uv32bit, param[1].uv32bit, param[2].uv32bit);
}

void STUB_glColor3uiv( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glColor3uiv( const GLuint *v )
    maxParam = 1;
    char buffer0[16*4096];
    READ_ARRAY_PARAM( 0, buffer0, TraceReader::TEXT_INT);
    TR.skipLine();
    CHECK_USER_CALL(glColor3uiv)
        UCT.glColor3uiv((const GLuint *)param[0].ptr);
    CHECK_GL_CALL(glColor3uiv)
        JT.glColor3uiv((const GLuint *)param[0].ptr);
}

void STUB_glColor3us( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glColor3us( GLushort red, GLushort green, GLushort blue )
    maxParam = 3;
    READ_PARAM(uv16bit,0);
    READ_PARAM(uv16bit,1);
    READ_PARAM(uv16bit,2);
    TR.skipLine();
    CHECK_USER_CALL(glColor3us)
        UCT.glColor3us(param[0].uv16bit, param[1].uv16bit, param[2].uv16bit);
    CHECK_GL_CALL(glColor3us)
        JT.glColor3us(param[0].uv16bit, param[1].uv16bit, param[2].uv16bit);
}

void STUB_glColor3usv( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glColor3usv( const GLushort *v )
    maxParam = 1;
    char buffer0[16*4096];
    READ_ARRAY_PARAM( 0, buffer0, TraceReader::TEXT_SHORT);
    TR.skipLine();
    CHECK_USER_CALL(glColor3usv)
        UCT.glColor3usv((const GLushort *)param[0].ptr);
    CHECK_GL_CALL(glColor3usv)
        JT.glColor3usv((const GLushort *)param[0].ptr);
}

void STUB_glColor4b( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glColor4b( GLbyte red, GLbyte green, GLbyte blue, GLbyte alpha )
    maxParam = 4;
    READ_PARAM(v8bit,0);
    READ_PARAM(v8bit,1);
    READ_PARAM(v8bit,2);
    READ_PARAM(v8bit,3);
    TR.skipLine();
    CHECK_USER_CALL(glColor4b)
        UCT.glColor4b(param[0].v8bit, param[1].v8bit, param[2].v8bit, param[3].v8bit);
    CHECK_GL_CALL(glColor4b)
        JT.glColor4b(param[0].v8bit, param[1].v8bit, param[2].v8bit, param[3].v8bit);
}

void STUB_glColor4bv( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glColor4bv( const GLbyte *v )
    maxParam = 1;
    char buffer0[16*4096];
    READ_ARRAY_PARAM( 0, buffer0, TraceReader::TEXT_BYTE);
    TR.skipLine();
    CHECK_USER_CALL(glColor4bv)
        UCT.glColor4bv((const GLbyte *)param[0].ptr);
    CHECK_GL_CALL(glColor4bv)
        JT.glColor4bv((const GLbyte *)param[0].ptr);
}

void STUB_glColor4d( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glColor4d( GLdouble red, GLdouble green, GLdouble blue, GLdouble alpha )
    maxParam = 4;
    READ_DOUBLE_PARAM(0);
    READ_DOUBLE_PARAM(1);
    READ_DOUBLE_PARAM(2);
    READ_DOUBLE_PARAM(3);
    TR.skipLine();
    CHECK_USER_CALL(glColor4d)
        UCT.glColor4d(param[0].fv64bit, param[1].fv64bit, param[2].fv64bit, param[3].fv64bit);
    CHECK_GL_CALL(glColor4d)
        JT.glColor4d(param[0].fv64bit, param[1].fv64bit, param[2].fv64bit, param[3].fv64bit);
}

void STUB_glColor4dv( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glColor4dv( const GLdouble *v )
    maxParam = 1;
    char buffer0[16*4096];
    READ_ARRAY_PARAM( 0, buffer0, TraceReader::TEXT_DOUBLE);
    TR.skipLine();
    CHECK_USER_CALL(glColor4dv)
        UCT.glColor4dv((const GLdouble *)param[0].ptr);
    CHECK_GL_CALL(glColor4dv)
        JT.glColor4dv((const GLdouble *)param[0].ptr);
}

void STUB_glColor4f( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glColor4f( GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha )
    maxParam = 4;
    READ_PARAM(fv32bit,0);
    READ_PARAM(fv32bit,1);
    READ_PARAM(fv32bit,2);
    READ_PARAM(fv32bit,3);
    TR.skipLine();
    CHECK_USER_CALL(glColor4f)
        UCT.glColor4f(param[0].fv32bit, param[1].fv32bit, param[2].fv32bit, param[3].fv32bit);
    CHECK_GL_CALL(glColor4f)
        JT.glColor4f(param[0].fv32bit, param[1].fv32bit, param[2].fv32bit, param[3].fv32bit);
}

void STUB_glColor4fv( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glColor4fv( const GLfloat *v )
    maxParam = 1;
    char buffer0[16*4096];
    READ_ARRAY_PARAM( 0, buffer0, TraceReader::TEXT_FLOAT);
    TR.skipLine();
    CHECK_USER_CALL(glColor4fv)
        UCT.glColor4fv((const GLfloat *)param[0].ptr);
    CHECK_GL_CALL(glColor4fv)
        JT.glColor4fv((const GLfloat *)param[0].ptr);
}

void STUB_glColor4hNV( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glColor4hNV( GLhalfNV, GLhalfNV, GLhalfNV, GLhalfNV )
    // Call not playable
    TR.skipCall();
}

void STUB_glColor4hvNV( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glColor4hvNV( const GLhalfNV * )
    // Call not playable
    TR.skipCall();
}

void STUB_glColor4i( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glColor4i( GLint red, GLint green, GLint blue, GLint alpha )
    maxParam = 4;
    READ_PARAM(v32bit,0);
    READ_PARAM(v32bit,1);
    READ_PARAM(v32bit,2);
    READ_PARAM(v32bit,3);
    TR.skipLine();
    CHECK_USER_CALL(glColor4i)
        UCT.glColor4i(param[0].v32bit, param[1].v32bit, param[2].v32bit, param[3].v32bit);
    CHECK_GL_CALL(glColor4i)
        JT.glColor4i(param[0].v32bit, param[1].v32bit, param[2].v32bit, param[3].v32bit);
}

void STUB_glColor4iv( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glColor4iv( const GLint *v )
    maxParam = 1;
    char buffer0[16*4096];
    READ_ARRAY_PARAM( 0, buffer0, TraceReader::TEXT_INT);
    TR.skipLine();
    CHECK_USER_CALL(glColor4iv)
        UCT.glColor4iv((const GLint *)param[0].ptr);
    CHECK_GL_CALL(glColor4iv)
        JT.glColor4iv((const GLint *)param[0].ptr);
}

void STUB_glColor4s( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glColor4s( GLshort red, GLshort green, GLshort blue, GLshort alpha )
    maxParam = 4;
    READ_PARAM(v16bit,0);
    READ_PARAM(v16bit,1);
    READ_PARAM(v16bit,2);
    READ_PARAM(v16bit,3);
    TR.skipLine();
    CHECK_USER_CALL(glColor4s)
        UCT.glColor4s(param[0].v16bit, param[1].v16bit, param[2].v16bit, param[3].v16bit);
    CHECK_GL_CALL(glColor4s)
        JT.glColor4s(param[0].v16bit, param[1].v16bit, param[2].v16bit, param[3].v16bit);
}

void STUB_glColor4sv( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glColor4sv( const GLshort *v )
    maxParam = 1;
    char buffer0[16*4096];
    READ_ARRAY_PARAM( 0, buffer0, TraceReader::TEXT_SHORT);
    TR.skipLine();
    CHECK_USER_CALL(glColor4sv)
        UCT.glColor4sv((const GLshort *)param[0].ptr);
    CHECK_GL_CALL(glColor4sv)
        JT.glColor4sv((const GLshort *)param[0].ptr);
}

void STUB_glColor4ub( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glColor4ub( GLubyte red, GLubyte green, GLubyte blue, GLubyte alpha )
    maxParam = 4;
    READ_PARAM(uv8bit,0);
    READ_PARAM(uv8bit,1);
    READ_PARAM(uv8bit,2);
    READ_PARAM(uv8bit,3);
    TR.skipLine();
    CHECK_USER_CALL(glColor4ub)
        UCT.glColor4ub(param[0].uv8bit, param[1].uv8bit, param[2].uv8bit, param[3].uv8bit);
    CHECK_GL_CALL(glColor4ub)
        JT.glColor4ub(param[0].uv8bit, param[1].uv8bit, param[2].uv8bit, param[3].uv8bit);
}

void STUB_glColor4ubv( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glColor4ubv( const GLubyte *v )
    maxParam = 1;
    char buffer0[16*4096];
    READ_ARRAY_PARAM( 0, buffer0, TraceReader::TEXT_BYTE);
    TR.skipLine();
    CHECK_USER_CALL(glColor4ubv)
        UCT.glColor4ubv((const GLubyte *)param[0].ptr);
    CHECK_GL_CALL(glColor4ubv)
        JT.glColor4ubv((const GLubyte *)param[0].ptr);
}

void STUB_glColor4ui( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glColor4ui( GLuint red, GLuint green, GLuint blue, GLuint alpha )
    maxParam = 4;
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_ENUM_PARAM(2);
    READ_ENUM_PARAM(3);
    TR.skipLine();
    CHECK_USER_CALL(glColor4ui)
        UCT.glColor4ui(param[0].uv32bit, param[1].uv32bit, param[2].uv32bit, param[3].uv32bit);
    CHECK_GL_CALL(glColor4ui)
        JT.glColor4ui(param[0].uv32bit, param[1].uv32bit, param[2].uv32bit, param[3].uv32bit);
}

void STUB_glColor4uiv( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glColor4uiv( const GLuint *v )
    maxParam = 1;
    char buffer0[16*4096];
    READ_ARRAY_PARAM( 0, buffer0, TraceReader::TEXT_INT);
    TR.skipLine();
    CHECK_USER_CALL(glColor4uiv)
        UCT.glColor4uiv((const GLuint *)param[0].ptr);
    CHECK_GL_CALL(glColor4uiv)
        JT.glColor4uiv((const GLuint *)param[0].ptr);
}

void STUB_glColor4us( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glColor4us( GLushort red, GLushort green, GLushort blue, GLushort alpha )
    maxParam = 4;
    READ_PARAM(uv16bit,0);
    READ_PARAM(uv16bit,1);
    READ_PARAM(uv16bit,2);
    READ_PARAM(uv16bit,3);
    TR.skipLine();
    CHECK_USER_CALL(glColor4us)
        UCT.glColor4us(param[0].uv16bit, param[1].uv16bit, param[2].uv16bit, param[3].uv16bit);
    CHECK_GL_CALL(glColor4us)
        JT.glColor4us(param[0].uv16bit, param[1].uv16bit, param[2].uv16bit, param[3].uv16bit);
}

void STUB_glColor4usv( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glColor4usv( const GLushort *v )
    maxParam = 1;
    char buffer0[16*4096];
    READ_ARRAY_PARAM( 0, buffer0, TraceReader::TEXT_SHORT);
    TR.skipLine();
    CHECK_USER_CALL(glColor4usv)
        UCT.glColor4usv((const GLushort *)param[0].ptr);
    CHECK_GL_CALL(glColor4usv)
        JT.glColor4usv((const GLushort *)param[0].ptr);
}

void STUB_glColorFragmentOp1ATI( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glColorFragmentOp1ATI( GLenum, GLuint, GLuint, GLuint, GLuint, GLuint, GLuint )
    maxParam = 7;
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_ENUM_PARAM(2);
    READ_ENUM_PARAM(3);
    READ_ENUM_PARAM(4);
    READ_ENUM_PARAM(5);
    READ_ENUM_PARAM(6);
    TR.skipLine();
    CHECK_USER_CALL(glColorFragmentOp1ATI)
        UCT.glColorFragmentOp1ATI(param[0].uv32bit, param[1].uv32bit, param[2].uv32bit, param[3].uv32bit, param[4].uv32bit, param[5].uv32bit, param[6].uv32bit);
    CHECK_GL_CALL(glColorFragmentOp1ATI)
        JT.glColorFragmentOp1ATI(param[0].uv32bit, param[1].uv32bit, param[2].uv32bit, param[3].uv32bit, param[4].uv32bit, param[5].uv32bit, param[6].uv32bit);
}

void STUB_glColorFragmentOp2ATI( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glColorFragmentOp2ATI( GLenum, GLuint, GLuint, GLuint, GLuint, GLuint, GLuint, GLuint, GLuint, GLuint )
    maxParam = 10;
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_ENUM_PARAM(2);
    READ_ENUM_PARAM(3);
    READ_ENUM_PARAM(4);
    READ_ENUM_PARAM(5);
    READ_ENUM_PARAM(6);
    READ_ENUM_PARAM(7);
    READ_ENUM_PARAM(8);
    READ_ENUM_PARAM(9);
    TR.skipLine();
    CHECK_USER_CALL(glColorFragmentOp2ATI)
        UCT.glColorFragmentOp2ATI(param[0].uv32bit, param[1].uv32bit, param[2].uv32bit, param[3].uv32bit, param[4].uv32bit, param[5].uv32bit, param[6].uv32bit, param[7].uv32bit, param[8].uv32bit, param[9].uv32bit);
    CHECK_GL_CALL(glColorFragmentOp2ATI)
        JT.glColorFragmentOp2ATI(param[0].uv32bit, param[1].uv32bit, param[2].uv32bit, param[3].uv32bit, param[4].uv32bit, param[5].uv32bit, param[6].uv32bit, param[7].uv32bit, param[8].uv32bit, param[9].uv32bit);
}

void STUB_glColorFragmentOp3ATI( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glColorFragmentOp3ATI( GLenum, GLuint, GLuint, GLuint, GLuint, GLuint, GLuint, GLuint, GLuint, GLuint, GLuint, GLuint, GLuint )
    maxParam = 13;
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_ENUM_PARAM(2);
    READ_ENUM_PARAM(3);
    READ_ENUM_PARAM(4);
    READ_ENUM_PARAM(5);
    READ_ENUM_PARAM(6);
    READ_ENUM_PARAM(7);
    READ_ENUM_PARAM(8);
    READ_ENUM_PARAM(9);
    READ_ENUM_PARAM(10);
    READ_ENUM_PARAM(11);
    READ_ENUM_PARAM(12);
    TR.skipLine();
    CHECK_USER_CALL(glColorFragmentOp3ATI)
        UCT.glColorFragmentOp3ATI(param[0].uv32bit, param[1].uv32bit, param[2].uv32bit, param[3].uv32bit, param[4].uv32bit, param[5].uv32bit, param[6].uv32bit, param[7].uv32bit, param[8].uv32bit, param[9].uv32bit, param[10].uv32bit, param[11].uv32bit, param[12].uv32bit);
    CHECK_GL_CALL(glColorFragmentOp3ATI)
        JT.glColorFragmentOp3ATI(param[0].uv32bit, param[1].uv32bit, param[2].uv32bit, param[3].uv32bit, param[4].uv32bit, param[5].uv32bit, param[6].uv32bit, param[7].uv32bit, param[8].uv32bit, param[9].uv32bit, param[10].uv32bit, param[11].uv32bit, param[12].uv32bit);
}

void STUB_glColorMask( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glColorMask( GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha )
    maxParam = 4;
    READ_BOOLEAN_PARAM(0);
    READ_BOOLEAN_PARAM(1);
    READ_BOOLEAN_PARAM(2);
    READ_BOOLEAN_PARAM(3);
    TR.skipLine();
    CHECK_USER_CALL(glColorMask)
        UCT.glColorMask(param[0].boolean, param[1].boolean, param[2].boolean, param[3].boolean);
    CHECK_GL_CALL(glColorMask)
        JT.glColorMask(param[0].boolean, param[1].boolean, param[2].boolean, param[3].boolean);
}

void STUB_glColorMaskIndexedEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glColorMaskIndexedEXT( GLuint, GLboolean, GLboolean, GLboolean, GLboolean )
    maxParam = 5;
    READ_ENUM_PARAM(0);
    READ_BOOLEAN_PARAM(1);
    READ_BOOLEAN_PARAM(2);
    READ_BOOLEAN_PARAM(3);
    READ_BOOLEAN_PARAM(4);
    TR.skipLine();
    CHECK_USER_CALL(glColorMaskIndexedEXT)
        UCT.glColorMaskIndexedEXT(param[0].uv32bit, param[1].boolean, param[2].boolean, param[3].boolean, param[4].boolean);
    CHECK_GL_CALL(glColorMaskIndexedEXT)
        JT.glColorMaskIndexedEXT(param[0].uv32bit, param[1].boolean, param[2].boolean, param[3].boolean, param[4].boolean);
}

void STUB_glColorMaski( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glColorMaski( GLuint, GLboolean, GLboolean, GLboolean, GLboolean )
    maxParam = 5;
    READ_ENUM_PARAM(0);
    READ_BOOLEAN_PARAM(1);
    READ_BOOLEAN_PARAM(2);
    READ_BOOLEAN_PARAM(3);
    READ_BOOLEAN_PARAM(4);
    TR.skipLine();
    CHECK_USER_CALL(glColorMaski)
        UCT.glColorMaski(param[0].uv32bit, param[1].boolean, param[2].boolean, param[3].boolean, param[4].boolean);
    CHECK_GL_CALL(glColorMaski)
        JT.glColorMaski(param[0].uv32bit, param[1].boolean, param[2].boolean, param[3].boolean, param[4].boolean);
}

void STUB_glColorMaterial( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glColorMaterial( GLenum face, GLenum mode )
    maxParam = 2;
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    TR.skipLine();
    CHECK_USER_CALL(glColorMaterial)
        UCT.glColorMaterial(param[0].uv32bit, param[1].uv32bit);
    CHECK_GL_CALL(glColorMaterial)
        JT.glColorMaterial(param[0].uv32bit, param[1].uv32bit);
}

void STUB_glColorPointer( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glColorPointer( GLint size, GLenum type, GLsizei stride, const GLvoid *ptr )
    maxParam = 4;
    char buffer0[16*4096];
    READ_PARAM(v32bit,0);
    READ_ENUM_PARAM(1);
    READ_PARAM(v32bit,2);
    READ_ARRAY_PARAM( 3, buffer0, TraceReader::TEXT_IGNORE);
    TR.skipLine();
    CHECK_USER_CALL(glColorPointer)
        UCT.glColorPointer(param[0].v32bit, param[1].uv32bit, param[2].v32bit, (const GLvoid *)param[3].ptr);
    CHECK_GL_CALL(glColorPointer)
        JT.glColorPointer(param[0].v32bit, param[1].uv32bit, param[2].v32bit, (const GLvoid *)param[3].ptr);
}

void STUB_glColorPointerEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glColorPointerEXT( GLint, GLenum, GLsizei, GLsizei, const GLvoid * )
    maxParam = 5;
    char buffer0[16*4096];
    READ_PARAM(v32bit,0);
    READ_ENUM_PARAM(1);
    READ_PARAM(v32bit,2);
    READ_PARAM(v32bit,3);
    READ_ARRAY_PARAM( 4, buffer0, TraceReader::TEXT_IGNORE);
    TR.skipLine();
    CHECK_USER_CALL(glColorPointerEXT)
        UCT.glColorPointerEXT(param[0].v32bit, param[1].uv32bit, param[2].v32bit, param[3].v32bit, (const GLvoid *)param[4].ptr);
    CHECK_GL_CALL(glColorPointerEXT)
        JT.glColorPointerEXT(param[0].v32bit, param[1].uv32bit, param[2].v32bit, param[3].v32bit, (const GLvoid *)param[4].ptr);
}

void STUB_glColorPointervINTEL( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glColorPointervINTEL( GLint, GLenum, const GLvoid ** )
    maxParam = 3;
    char buffer0[16*4096];
    READ_PARAM(v32bit,0);
    READ_ENUM_PARAM(1);
    READ_ARRAY_PARAM( 2, buffer0, TraceReader::TEXT_IGNORE);
    TR.skipLine();
    CHECK_USER_CALL(glColorPointervINTEL)
        UCT.glColorPointervINTEL(param[0].v32bit, param[1].uv32bit, (const GLvoid **)param[2].ptr);
    CHECK_GL_CALL(glColorPointervINTEL)
        JT.glColorPointervINTEL(param[0].v32bit, param[1].uv32bit, (const GLvoid **)param[2].ptr);
}

void STUB_glColorSubTable( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glColorSubTable( GLenum target, GLsizei start, GLsizei count, GLenum format, GLenum type, const GLvoid *data )
    maxParam = 6;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_PARAM(v32bit,1);
    READ_PARAM(v32bit,2);
    READ_ENUM_PARAM(3);
    READ_ENUM_PARAM(4);
    READ_ARRAY_PARAM( 5, buffer0, TraceReader::TEXT_IGNORE);
    TR.skipLine();
    CHECK_USER_CALL(glColorSubTable)
        UCT.glColorSubTable(param[0].uv32bit, param[1].v32bit, param[2].v32bit, param[3].uv32bit, param[4].uv32bit, (const GLvoid *)param[5].ptr);
    CHECK_GL_CALL(glColorSubTable)
        JT.glColorSubTable(param[0].uv32bit, param[1].v32bit, param[2].v32bit, param[3].uv32bit, param[4].uv32bit, (const GLvoid *)param[5].ptr);
}

void STUB_glColorSubTableEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glColorSubTableEXT( GLenum, GLsizei, GLsizei, GLenum, GLenum, const GLvoid * )
    maxParam = 6;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_PARAM(v32bit,1);
    READ_PARAM(v32bit,2);
    READ_ENUM_PARAM(3);
    READ_ENUM_PARAM(4);
    READ_ARRAY_PARAM( 5, buffer0, TraceReader::TEXT_IGNORE);
    TR.skipLine();
    CHECK_USER_CALL(glColorSubTableEXT)
        UCT.glColorSubTableEXT(param[0].uv32bit, param[1].v32bit, param[2].v32bit, param[3].uv32bit, param[4].uv32bit, (const GLvoid *)param[5].ptr);
    CHECK_GL_CALL(glColorSubTableEXT)
        JT.glColorSubTableEXT(param[0].uv32bit, param[1].v32bit, param[2].v32bit, param[3].uv32bit, param[4].uv32bit, (const GLvoid *)param[5].ptr);
}

void STUB_glColorTable( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glColorTable( GLenum target, GLenum internalformat, GLsizei width, GLenum format, GLenum type, const GLvoid *table )
    maxParam = 6;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_PARAM(v32bit,2);
    READ_ENUM_PARAM(3);
    READ_ENUM_PARAM(4);
    READ_ARRAY_PARAM( 5, buffer0, TraceReader::TEXT_IGNORE);
    TR.skipLine();
    CHECK_USER_CALL(glColorTable)
        UCT.glColorTable(param[0].uv32bit, param[1].uv32bit, param[2].v32bit, param[3].uv32bit, param[4].uv32bit, (const GLvoid *)param[5].ptr);
    CHECK_GL_CALL(glColorTable)
        JT.glColorTable(param[0].uv32bit, param[1].uv32bit, param[2].v32bit, param[3].uv32bit, param[4].uv32bit, (const GLvoid *)param[5].ptr);
}

void STUB_glColorTableEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glColorTableEXT( GLenum, GLenum, GLsizei, GLenum, GLenum, const GLvoid * )
    maxParam = 6;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_PARAM(v32bit,2);
    READ_ENUM_PARAM(3);
    READ_ENUM_PARAM(4);
    READ_ARRAY_PARAM( 5, buffer0, TraceReader::TEXT_IGNORE);
    TR.skipLine();
    CHECK_USER_CALL(glColorTableEXT)
        UCT.glColorTableEXT(param[0].uv32bit, param[1].uv32bit, param[2].v32bit, param[3].uv32bit, param[4].uv32bit, (const GLvoid *)param[5].ptr);
    CHECK_GL_CALL(glColorTableEXT)
        JT.glColorTableEXT(param[0].uv32bit, param[1].uv32bit, param[2].v32bit, param[3].uv32bit, param[4].uv32bit, (const GLvoid *)param[5].ptr);
}

void STUB_glColorTableParameterfv( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glColorTableParameterfv( GLenum target, GLenum pname, const GLfloat *params )
    maxParam = 3;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_ARRAY_PARAM( 2, buffer0, TraceReader::TEXT_FLOAT);
    TR.skipLine();
    CHECK_USER_CALL(glColorTableParameterfv)
        UCT.glColorTableParameterfv(param[0].uv32bit, param[1].uv32bit, (const GLfloat *)param[2].ptr);
    CHECK_GL_CALL(glColorTableParameterfv)
        JT.glColorTableParameterfv(param[0].uv32bit, param[1].uv32bit, (const GLfloat *)param[2].ptr);
}

void STUB_glColorTableParameterfvSGI( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glColorTableParameterfvSGI( GLenum, GLenum, const GLfloat * )
    maxParam = 3;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_ARRAY_PARAM( 2, buffer0, TraceReader::TEXT_FLOAT);
    TR.skipLine();
    CHECK_USER_CALL(glColorTableParameterfvSGI)
        UCT.glColorTableParameterfvSGI(param[0].uv32bit, param[1].uv32bit, (const GLfloat *)param[2].ptr);
    CHECK_GL_CALL(glColorTableParameterfvSGI)
        JT.glColorTableParameterfvSGI(param[0].uv32bit, param[1].uv32bit, (const GLfloat *)param[2].ptr);
}

void STUB_glColorTableParameteriv( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glColorTableParameteriv( GLenum target, GLenum pname, const GLint *params )
    maxParam = 3;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_ARRAY_PARAM( 2, buffer0, TraceReader::TEXT_INT);
    TR.skipLine();
    CHECK_USER_CALL(glColorTableParameteriv)
        UCT.glColorTableParameteriv(param[0].uv32bit, param[1].uv32bit, (const GLint *)param[2].ptr);
    CHECK_GL_CALL(glColorTableParameteriv)
        JT.glColorTableParameteriv(param[0].uv32bit, param[1].uv32bit, (const GLint *)param[2].ptr);
}

void STUB_glColorTableParameterivSGI( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glColorTableParameterivSGI( GLenum, GLenum, const GLint * )
    maxParam = 3;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_ARRAY_PARAM( 2, buffer0, TraceReader::TEXT_INT);
    TR.skipLine();
    CHECK_USER_CALL(glColorTableParameterivSGI)
        UCT.glColorTableParameterivSGI(param[0].uv32bit, param[1].uv32bit, (const GLint *)param[2].ptr);
    CHECK_GL_CALL(glColorTableParameterivSGI)
        JT.glColorTableParameterivSGI(param[0].uv32bit, param[1].uv32bit, (const GLint *)param[2].ptr);
}

void STUB_glColorTableSGI( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glColorTableSGI( GLenum, GLenum, GLsizei, GLenum, GLenum, const GLvoid * )
    maxParam = 6;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_PARAM(v32bit,2);
    READ_ENUM_PARAM(3);
    READ_ENUM_PARAM(4);
    READ_ARRAY_PARAM( 5, buffer0, TraceReader::TEXT_IGNORE);
    TR.skipLine();
    CHECK_USER_CALL(glColorTableSGI)
        UCT.glColorTableSGI(param[0].uv32bit, param[1].uv32bit, param[2].v32bit, param[3].uv32bit, param[4].uv32bit, (const GLvoid *)param[5].ptr);
    CHECK_GL_CALL(glColorTableSGI)
        JT.glColorTableSGI(param[0].uv32bit, param[1].uv32bit, param[2].v32bit, param[3].uv32bit, param[4].uv32bit, (const GLvoid *)param[5].ptr);
}

void STUB_glCombinerInputNV( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glCombinerInputNV( GLenum, GLenum, GLenum, GLenum, GLenum, GLenum )
    maxParam = 6;
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_ENUM_PARAM(2);
    READ_ENUM_PARAM(3);
    READ_ENUM_PARAM(4);
    READ_ENUM_PARAM(5);
    TR.skipLine();
    CHECK_USER_CALL(glCombinerInputNV)
        UCT.glCombinerInputNV(param[0].uv32bit, param[1].uv32bit, param[2].uv32bit, param[3].uv32bit, param[4].uv32bit, param[5].uv32bit);
    CHECK_GL_CALL(glCombinerInputNV)
        JT.glCombinerInputNV(param[0].uv32bit, param[1].uv32bit, param[2].uv32bit, param[3].uv32bit, param[4].uv32bit, param[5].uv32bit);
}

void STUB_glCombinerOutputNV( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glCombinerOutputNV( GLenum, GLenum, GLenum, GLenum, GLenum, GLenum, GLenum, GLboolean, GLboolean, GLboolean )
    maxParam = 10;
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_ENUM_PARAM(2);
    READ_ENUM_PARAM(3);
    READ_ENUM_PARAM(4);
    READ_ENUM_PARAM(5);
    READ_ENUM_PARAM(6);
    READ_BOOLEAN_PARAM(7);
    READ_BOOLEAN_PARAM(8);
    READ_BOOLEAN_PARAM(9);
    TR.skipLine();
    CHECK_USER_CALL(glCombinerOutputNV)
        UCT.glCombinerOutputNV(param[0].uv32bit, param[1].uv32bit, param[2].uv32bit, param[3].uv32bit, param[4].uv32bit, param[5].uv32bit, param[6].uv32bit, param[7].boolean, param[8].boolean, param[9].boolean);
    CHECK_GL_CALL(glCombinerOutputNV)
        JT.glCombinerOutputNV(param[0].uv32bit, param[1].uv32bit, param[2].uv32bit, param[3].uv32bit, param[4].uv32bit, param[5].uv32bit, param[6].uv32bit, param[7].boolean, param[8].boolean, param[9].boolean);
}

void STUB_glCombinerParameterfNV( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glCombinerParameterfNV( GLenum, GLfloat )
    maxParam = 2;
    READ_ENUM_PARAM(0);
    READ_PARAM(fv32bit,1);
    TR.skipLine();
    CHECK_USER_CALL(glCombinerParameterfNV)
        UCT.glCombinerParameterfNV(param[0].uv32bit, param[1].fv32bit);
    CHECK_GL_CALL(glCombinerParameterfNV)
        JT.glCombinerParameterfNV(param[0].uv32bit, param[1].fv32bit);
}

void STUB_glCombinerParameterfvNV( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glCombinerParameterfvNV( GLenum, const GLfloat * )
    maxParam = 2;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ARRAY_PARAM( 1, buffer0, TraceReader::TEXT_FLOAT);
    TR.skipLine();
    CHECK_USER_CALL(glCombinerParameterfvNV)
        UCT.glCombinerParameterfvNV(param[0].uv32bit, (const GLfloat *)param[1].ptr);
    CHECK_GL_CALL(glCombinerParameterfvNV)
        JT.glCombinerParameterfvNV(param[0].uv32bit, (const GLfloat *)param[1].ptr);
}

void STUB_glCombinerParameteriNV( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glCombinerParameteriNV( GLenum, GLint )
    maxParam = 2;
    READ_ENUM_PARAM(0);
    READ_PARAM(v32bit,1);
    TR.skipLine();
    CHECK_USER_CALL(glCombinerParameteriNV)
        UCT.glCombinerParameteriNV(param[0].uv32bit, param[1].v32bit);
    CHECK_GL_CALL(glCombinerParameteriNV)
        JT.glCombinerParameteriNV(param[0].uv32bit, param[1].v32bit);
}

void STUB_glCombinerParameterivNV( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glCombinerParameterivNV( GLenum, const GLint * )
    maxParam = 2;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ARRAY_PARAM( 1, buffer0, TraceReader::TEXT_INT);
    TR.skipLine();
    CHECK_USER_CALL(glCombinerParameterivNV)
        UCT.glCombinerParameterivNV(param[0].uv32bit, (const GLint *)param[1].ptr);
    CHECK_GL_CALL(glCombinerParameterivNV)
        JT.glCombinerParameterivNV(param[0].uv32bit, (const GLint *)param[1].ptr);
}

void STUB_glCombinerStageParameterfvNV( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glCombinerStageParameterfvNV( GLenum, GLenum, const GLfloat * )
    maxParam = 3;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_ARRAY_PARAM( 2, buffer0, TraceReader::TEXT_FLOAT);
    TR.skipLine();
    CHECK_USER_CALL(glCombinerStageParameterfvNV)
        UCT.glCombinerStageParameterfvNV(param[0].uv32bit, param[1].uv32bit, (const GLfloat *)param[2].ptr);
    CHECK_GL_CALL(glCombinerStageParameterfvNV)
        JT.glCombinerStageParameterfvNV(param[0].uv32bit, param[1].uv32bit, (const GLfloat *)param[2].ptr);
}

void STUB_glCompileShader( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glCompileShader( GLuint )
    maxParam = 1;
    READ_ENUM_PARAM(0);
    TR.skipLine();
    CHECK_USER_CALL(glCompileShader)
        UCT.glCompileShader(param[0].uv32bit);
    CHECK_GL_CALL(glCompileShader)
        JT.glCompileShader(param[0].uv32bit);
}

void STUB_glCompileShaderARB( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glCompileShaderARB( GLhandleARB )
    maxParam = 1;
    READ_ENUM_PARAM(0);
    TR.skipLine();
    CHECK_USER_CALL(glCompileShaderARB)
        UCT.glCompileShaderARB(param[0].uv32bit);
    CHECK_GL_CALL(glCompileShaderARB)
        JT.glCompileShaderARB(param[0].uv32bit);
}

void STUB_glCompressedMultiTexImage1DEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glCompressedMultiTexImage1DEXT( GLenum, GLenum, GLint, GLenum, GLsizei, GLint, GLsizei, const GLvoid * )
    maxParam = 8;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_PARAM(v32bit,2);
    READ_ENUM_PARAM(3);
    READ_PARAM(v32bit,4);
    READ_PARAM(v32bit,5);
    READ_PARAM(v32bit,6);
    READ_ARRAY_PARAM( 7, buffer0, TraceReader::TEXT_IGNORE);
    TR.skipLine();
    CHECK_USER_CALL(glCompressedMultiTexImage1DEXT)
        UCT.glCompressedMultiTexImage1DEXT(param[0].uv32bit, param[1].uv32bit, param[2].v32bit, param[3].uv32bit, param[4].v32bit, param[5].v32bit, param[6].v32bit, (const GLvoid *)param[7].ptr);
    CHECK_GL_CALL(glCompressedMultiTexImage1DEXT)
        JT.glCompressedMultiTexImage1DEXT(param[0].uv32bit, param[1].uv32bit, param[2].v32bit, param[3].uv32bit, param[4].v32bit, param[5].v32bit, param[6].v32bit, (const GLvoid *)param[7].ptr);
}

void STUB_glCompressedMultiTexImage2DEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glCompressedMultiTexImage2DEXT( GLenum, GLenum, GLint, GLenum, GLsizei, GLsizei, GLint, GLsizei, const GLvoid * )
    maxParam = 9;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_PARAM(v32bit,2);
    READ_ENUM_PARAM(3);
    READ_PARAM(v32bit,4);
    READ_PARAM(v32bit,5);
    READ_PARAM(v32bit,6);
    READ_PARAM(v32bit,7);
    READ_ARRAY_PARAM( 8, buffer0, TraceReader::TEXT_IGNORE);
    TR.skipLine();
    CHECK_USER_CALL(glCompressedMultiTexImage2DEXT)
        UCT.glCompressedMultiTexImage2DEXT(param[0].uv32bit, param[1].uv32bit, param[2].v32bit, param[3].uv32bit, param[4].v32bit, param[5].v32bit, param[6].v32bit, param[7].v32bit, (const GLvoid *)param[8].ptr);
    CHECK_GL_CALL(glCompressedMultiTexImage2DEXT)
        JT.glCompressedMultiTexImage2DEXT(param[0].uv32bit, param[1].uv32bit, param[2].v32bit, param[3].uv32bit, param[4].v32bit, param[5].v32bit, param[6].v32bit, param[7].v32bit, (const GLvoid *)param[8].ptr);
}

void STUB_glCompressedMultiTexImage3DEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glCompressedMultiTexImage3DEXT( GLenum, GLenum, GLint, GLenum, GLsizei, GLsizei, GLsizei, GLint, GLsizei, const GLvoid * )
    maxParam = 10;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_PARAM(v32bit,2);
    READ_ENUM_PARAM(3);
    READ_PARAM(v32bit,4);
    READ_PARAM(v32bit,5);
    READ_PARAM(v32bit,6);
    READ_PARAM(v32bit,7);
    READ_PARAM(v32bit,8);
    READ_ARRAY_PARAM( 9, buffer0, TraceReader::TEXT_IGNORE);
    TR.skipLine();
    CHECK_USER_CALL(glCompressedMultiTexImage3DEXT)
        UCT.glCompressedMultiTexImage3DEXT(param[0].uv32bit, param[1].uv32bit, param[2].v32bit, param[3].uv32bit, param[4].v32bit, param[5].v32bit, param[6].v32bit, param[7].v32bit, param[8].v32bit, (const GLvoid *)param[9].ptr);
    CHECK_GL_CALL(glCompressedMultiTexImage3DEXT)
        JT.glCompressedMultiTexImage3DEXT(param[0].uv32bit, param[1].uv32bit, param[2].v32bit, param[3].uv32bit, param[4].v32bit, param[5].v32bit, param[6].v32bit, param[7].v32bit, param[8].v32bit, (const GLvoid *)param[9].ptr);
}

void STUB_glCompressedMultiTexSubImage1DEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glCompressedMultiTexSubImage1DEXT( GLenum, GLenum, GLint, GLint, GLsizei, GLenum, GLsizei, const GLvoid * )
    maxParam = 8;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_PARAM(v32bit,2);
    READ_PARAM(v32bit,3);
    READ_PARAM(v32bit,4);
    READ_ENUM_PARAM(5);
    READ_PARAM(v32bit,6);
    READ_ARRAY_PARAM( 7, buffer0, TraceReader::TEXT_IGNORE);
    TR.skipLine();
    CHECK_USER_CALL(glCompressedMultiTexSubImage1DEXT)
        UCT.glCompressedMultiTexSubImage1DEXT(param[0].uv32bit, param[1].uv32bit, param[2].v32bit, param[3].v32bit, param[4].v32bit, param[5].uv32bit, param[6].v32bit, (const GLvoid *)param[7].ptr);
    CHECK_GL_CALL(glCompressedMultiTexSubImage1DEXT)
        JT.glCompressedMultiTexSubImage1DEXT(param[0].uv32bit, param[1].uv32bit, param[2].v32bit, param[3].v32bit, param[4].v32bit, param[5].uv32bit, param[6].v32bit, (const GLvoid *)param[7].ptr);
}

void STUB_glCompressedMultiTexSubImage2DEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glCompressedMultiTexSubImage2DEXT( GLenum, GLenum, GLint, GLint, GLint, GLsizei, GLsizei, GLenum, GLsizei, const GLvoid * )
    maxParam = 10;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_PARAM(v32bit,2);
    READ_PARAM(v32bit,3);
    READ_PARAM(v32bit,4);
    READ_PARAM(v32bit,5);
    READ_PARAM(v32bit,6);
    READ_ENUM_PARAM(7);
    READ_PARAM(v32bit,8);
    READ_ARRAY_PARAM( 9, buffer0, TraceReader::TEXT_IGNORE);
    TR.skipLine();
    CHECK_USER_CALL(glCompressedMultiTexSubImage2DEXT)
        UCT.glCompressedMultiTexSubImage2DEXT(param[0].uv32bit, param[1].uv32bit, param[2].v32bit, param[3].v32bit, param[4].v32bit, param[5].v32bit, param[6].v32bit, param[7].uv32bit, param[8].v32bit, (const GLvoid *)param[9].ptr);
    CHECK_GL_CALL(glCompressedMultiTexSubImage2DEXT)
        JT.glCompressedMultiTexSubImage2DEXT(param[0].uv32bit, param[1].uv32bit, param[2].v32bit, param[3].v32bit, param[4].v32bit, param[5].v32bit, param[6].v32bit, param[7].uv32bit, param[8].v32bit, (const GLvoid *)param[9].ptr);
}

void STUB_glCompressedMultiTexSubImage3DEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glCompressedMultiTexSubImage3DEXT( GLenum, GLenum, GLint, GLint, GLint, GLint, GLsizei, GLsizei, GLsizei, GLenum, GLsizei, const GLvoid * )
    maxParam = 12;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_PARAM(v32bit,2);
    READ_PARAM(v32bit,3);
    READ_PARAM(v32bit,4);
    READ_PARAM(v32bit,5);
    READ_PARAM(v32bit,6);
    READ_PARAM(v32bit,7);
    READ_PARAM(v32bit,8);
    READ_ENUM_PARAM(9);
    READ_PARAM(v32bit,10);
    READ_ARRAY_PARAM( 11, buffer0, TraceReader::TEXT_IGNORE);
    TR.skipLine();
    CHECK_USER_CALL(glCompressedMultiTexSubImage3DEXT)
        UCT.glCompressedMultiTexSubImage3DEXT(param[0].uv32bit, param[1].uv32bit, param[2].v32bit, param[3].v32bit, param[4].v32bit, param[5].v32bit, param[6].v32bit, param[7].v32bit, param[8].v32bit, param[9].uv32bit, param[10].v32bit, (const GLvoid *)param[11].ptr);
    CHECK_GL_CALL(glCompressedMultiTexSubImage3DEXT)
        JT.glCompressedMultiTexSubImage3DEXT(param[0].uv32bit, param[1].uv32bit, param[2].v32bit, param[3].v32bit, param[4].v32bit, param[5].v32bit, param[6].v32bit, param[7].v32bit, param[8].v32bit, param[9].uv32bit, param[10].v32bit, (const GLvoid *)param[11].ptr);
}

void STUB_glCompressedTexImage1D( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glCompressedTexImage1D( GLenum target, GLint level, GLenum internalformat, GLsizei width, GLint border, GLsizei imageSize, const GLvoid *data )
    maxParam = 7;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_PARAM(v32bit,1);
    READ_ENUM_PARAM(2);
    READ_PARAM(v32bit,3);
    READ_PARAM(v32bit,4);
    READ_PARAM(v32bit,5);
    READ_ARRAY_PARAM( 6, buffer0, TraceReader::TEXT_IGNORE);
    TR.skipLine();
    CHECK_USER_CALL(glCompressedTexImage1D)
        UCT.glCompressedTexImage1D(param[0].uv32bit, param[1].v32bit, param[2].uv32bit, param[3].v32bit, param[4].v32bit, param[5].v32bit, (const GLvoid *)param[6].ptr);
    CHECK_GL_CALL(glCompressedTexImage1D)
        JT.glCompressedTexImage1D(param[0].uv32bit, param[1].v32bit, param[2].uv32bit, param[3].v32bit, param[4].v32bit, param[5].v32bit, (const GLvoid *)param[6].ptr);
}

void STUB_glCompressedTexImage1DARB( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glCompressedTexImage1DARB( GLenum, GLint, GLenum, GLsizei, GLint, GLsizei, const GLvoid * )
    maxParam = 7;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_PARAM(v32bit,1);
    READ_ENUM_PARAM(2);
    READ_PARAM(v32bit,3);
    READ_PARAM(v32bit,4);
    READ_PARAM(v32bit,5);
    READ_ARRAY_PARAM( 6, buffer0, TraceReader::TEXT_IGNORE);
    TR.skipLine();
    CHECK_USER_CALL(glCompressedTexImage1DARB)
        UCT.glCompressedTexImage1DARB(param[0].uv32bit, param[1].v32bit, param[2].uv32bit, param[3].v32bit, param[4].v32bit, param[5].v32bit, (const GLvoid *)param[6].ptr);
    CHECK_GL_CALL(glCompressedTexImage1DARB)
        JT.glCompressedTexImage1DARB(param[0].uv32bit, param[1].v32bit, param[2].uv32bit, param[3].v32bit, param[4].v32bit, param[5].v32bit, (const GLvoid *)param[6].ptr);
}

void STUB_glCompressedTexImage2D( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glCompressedTexImage2D( GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const GLvoid *data )
    maxParam = 8;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_PARAM(v32bit,1);
    READ_ENUM_PARAM(2);
    READ_PARAM(v32bit,3);
    READ_PARAM(v32bit,4);
    READ_PARAM(v32bit,5);
    READ_PARAM(v32bit,6);
    READ_ARRAY_PARAM( 7, buffer0, TraceReader::TEXT_IGNORE);
    TR.skipLine();
    CHECK_USER_CALL(glCompressedTexImage2D)
        UCT.glCompressedTexImage2D(param[0].uv32bit, param[1].v32bit, param[2].uv32bit, param[3].v32bit, param[4].v32bit, param[5].v32bit, param[6].v32bit, (const GLvoid *)param[7].ptr);
    CHECK_GL_CALL(glCompressedTexImage2D)
        JT.glCompressedTexImage2D(param[0].uv32bit, param[1].v32bit, param[2].uv32bit, param[3].v32bit, param[4].v32bit, param[5].v32bit, param[6].v32bit, (const GLvoid *)param[7].ptr);
}

void STUB_glCompressedTexImage2DARB( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glCompressedTexImage2DARB( GLenum, GLint, GLenum, GLsizei, GLsizei, GLint, GLsizei, const GLvoid * )
    maxParam = 8;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_PARAM(v32bit,1);
    READ_ENUM_PARAM(2);
    READ_PARAM(v32bit,3);
    READ_PARAM(v32bit,4);
    READ_PARAM(v32bit,5);
    READ_PARAM(v32bit,6);
    READ_ARRAY_PARAM( 7, buffer0, TraceReader::TEXT_IGNORE);
    TR.skipLine();
    CHECK_USER_CALL(glCompressedTexImage2DARB)
        UCT.glCompressedTexImage2DARB(param[0].uv32bit, param[1].v32bit, param[2].uv32bit, param[3].v32bit, param[4].v32bit, param[5].v32bit, param[6].v32bit, (const GLvoid *)param[7].ptr);
    CHECK_GL_CALL(glCompressedTexImage2DARB)
        JT.glCompressedTexImage2DARB(param[0].uv32bit, param[1].v32bit, param[2].uv32bit, param[3].v32bit, param[4].v32bit, param[5].v32bit, param[6].v32bit, (const GLvoid *)param[7].ptr);
}

void STUB_glCompressedTexImage3D( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glCompressedTexImage3D( GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const GLvoid *data )
    maxParam = 9;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_PARAM(v32bit,1);
    READ_ENUM_PARAM(2);
    READ_PARAM(v32bit,3);
    READ_PARAM(v32bit,4);
    READ_PARAM(v32bit,5);
    READ_PARAM(v32bit,6);
    READ_PARAM(v32bit,7);
    READ_ARRAY_PARAM( 8, buffer0, TraceReader::TEXT_IGNORE);
    TR.skipLine();
    CHECK_USER_CALL(glCompressedTexImage3D)
        UCT.glCompressedTexImage3D(param[0].uv32bit, param[1].v32bit, param[2].uv32bit, param[3].v32bit, param[4].v32bit, param[5].v32bit, param[6].v32bit, param[7].v32bit, (const GLvoid *)param[8].ptr);
    CHECK_GL_CALL(glCompressedTexImage3D)
        JT.glCompressedTexImage3D(param[0].uv32bit, param[1].v32bit, param[2].uv32bit, param[3].v32bit, param[4].v32bit, param[5].v32bit, param[6].v32bit, param[7].v32bit, (const GLvoid *)param[8].ptr);
}

void STUB_glCompressedTexImage3DARB( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glCompressedTexImage3DARB( GLenum, GLint, GLenum, GLsizei, GLsizei, GLsizei, GLint, GLsizei, const GLvoid * )
    maxParam = 9;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_PARAM(v32bit,1);
    READ_ENUM_PARAM(2);
    READ_PARAM(v32bit,3);
    READ_PARAM(v32bit,4);
    READ_PARAM(v32bit,5);
    READ_PARAM(v32bit,6);
    READ_PARAM(v32bit,7);
    READ_ARRAY_PARAM( 8, buffer0, TraceReader::TEXT_IGNORE);
    TR.skipLine();
    CHECK_USER_CALL(glCompressedTexImage3DARB)
        UCT.glCompressedTexImage3DARB(param[0].uv32bit, param[1].v32bit, param[2].uv32bit, param[3].v32bit, param[4].v32bit, param[5].v32bit, param[6].v32bit, param[7].v32bit, (const GLvoid *)param[8].ptr);
    CHECK_GL_CALL(glCompressedTexImage3DARB)
        JT.glCompressedTexImage3DARB(param[0].uv32bit, param[1].v32bit, param[2].uv32bit, param[3].v32bit, param[4].v32bit, param[5].v32bit, param[6].v32bit, param[7].v32bit, (const GLvoid *)param[8].ptr);
}

void STUB_glCompressedTexSubImage1D( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glCompressedTexSubImage1D( GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLsizei imageSize, const GLvoid *data )
    maxParam = 7;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_PARAM(v32bit,1);
    READ_PARAM(v32bit,2);
    READ_PARAM(v32bit,3);
    READ_ENUM_PARAM(4);
    READ_PARAM(v32bit,5);
    READ_ARRAY_PARAM( 6, buffer0, TraceReader::TEXT_IGNORE);
    TR.skipLine();
    CHECK_USER_CALL(glCompressedTexSubImage1D)
        UCT.glCompressedTexSubImage1D(param[0].uv32bit, param[1].v32bit, param[2].v32bit, param[3].v32bit, param[4].uv32bit, param[5].v32bit, (const GLvoid *)param[6].ptr);
    CHECK_GL_CALL(glCompressedTexSubImage1D)
        JT.glCompressedTexSubImage1D(param[0].uv32bit, param[1].v32bit, param[2].v32bit, param[3].v32bit, param[4].uv32bit, param[5].v32bit, (const GLvoid *)param[6].ptr);
}

void STUB_glCompressedTexSubImage1DARB( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glCompressedTexSubImage1DARB( GLenum, GLint, GLint, GLsizei, GLenum, GLsizei, const GLvoid * )
    maxParam = 7;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_PARAM(v32bit,1);
    READ_PARAM(v32bit,2);
    READ_PARAM(v32bit,3);
    READ_ENUM_PARAM(4);
    READ_PARAM(v32bit,5);
    READ_ARRAY_PARAM( 6, buffer0, TraceReader::TEXT_IGNORE);
    TR.skipLine();
    CHECK_USER_CALL(glCompressedTexSubImage1DARB)
        UCT.glCompressedTexSubImage1DARB(param[0].uv32bit, param[1].v32bit, param[2].v32bit, param[3].v32bit, param[4].uv32bit, param[5].v32bit, (const GLvoid *)param[6].ptr);
    CHECK_GL_CALL(glCompressedTexSubImage1DARB)
        JT.glCompressedTexSubImage1DARB(param[0].uv32bit, param[1].v32bit, param[2].v32bit, param[3].v32bit, param[4].uv32bit, param[5].v32bit, (const GLvoid *)param[6].ptr);
}

void STUB_glCompressedTexSubImage2D( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glCompressedTexSubImage2D( GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const GLvoid *data )
    maxParam = 9;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_PARAM(v32bit,1);
    READ_PARAM(v32bit,2);
    READ_PARAM(v32bit,3);
    READ_PARAM(v32bit,4);
    READ_PARAM(v32bit,5);
    READ_ENUM_PARAM(6);
    READ_PARAM(v32bit,7);
    READ_ARRAY_PARAM( 8, buffer0, TraceReader::TEXT_IGNORE);
    TR.skipLine();
    CHECK_USER_CALL(glCompressedTexSubImage2D)
        UCT.glCompressedTexSubImage2D(param[0].uv32bit, param[1].v32bit, param[2].v32bit, param[3].v32bit, param[4].v32bit, param[5].v32bit, param[6].uv32bit, param[7].v32bit, (const GLvoid *)param[8].ptr);
    CHECK_GL_CALL(glCompressedTexSubImage2D)
        JT.glCompressedTexSubImage2D(param[0].uv32bit, param[1].v32bit, param[2].v32bit, param[3].v32bit, param[4].v32bit, param[5].v32bit, param[6].uv32bit, param[7].v32bit, (const GLvoid *)param[8].ptr);
}

void STUB_glCompressedTexSubImage2DARB( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glCompressedTexSubImage2DARB( GLenum, GLint, GLint, GLint, GLsizei, GLsizei, GLenum, GLsizei, const GLvoid * )
    maxParam = 9;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_PARAM(v32bit,1);
    READ_PARAM(v32bit,2);
    READ_PARAM(v32bit,3);
    READ_PARAM(v32bit,4);
    READ_PARAM(v32bit,5);
    READ_ENUM_PARAM(6);
    READ_PARAM(v32bit,7);
    READ_ARRAY_PARAM( 8, buffer0, TraceReader::TEXT_IGNORE);
    TR.skipLine();
    CHECK_USER_CALL(glCompressedTexSubImage2DARB)
        UCT.glCompressedTexSubImage2DARB(param[0].uv32bit, param[1].v32bit, param[2].v32bit, param[3].v32bit, param[4].v32bit, param[5].v32bit, param[6].uv32bit, param[7].v32bit, (const GLvoid *)param[8].ptr);
    CHECK_GL_CALL(glCompressedTexSubImage2DARB)
        JT.glCompressedTexSubImage2DARB(param[0].uv32bit, param[1].v32bit, param[2].v32bit, param[3].v32bit, param[4].v32bit, param[5].v32bit, param[6].uv32bit, param[7].v32bit, (const GLvoid *)param[8].ptr);
}

void STUB_glCompressedTexSubImage3D( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glCompressedTexSubImage3D( GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const GLvoid *data )
    maxParam = 11;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_PARAM(v32bit,1);
    READ_PARAM(v32bit,2);
    READ_PARAM(v32bit,3);
    READ_PARAM(v32bit,4);
    READ_PARAM(v32bit,5);
    READ_PARAM(v32bit,6);
    READ_PARAM(v32bit,7);
    READ_ENUM_PARAM(8);
    READ_PARAM(v32bit,9);
    READ_ARRAY_PARAM( 10, buffer0, TraceReader::TEXT_IGNORE);
    TR.skipLine();
    CHECK_USER_CALL(glCompressedTexSubImage3D)
        UCT.glCompressedTexSubImage3D(param[0].uv32bit, param[1].v32bit, param[2].v32bit, param[3].v32bit, param[4].v32bit, param[5].v32bit, param[6].v32bit, param[7].v32bit, param[8].uv32bit, param[9].v32bit, (const GLvoid *)param[10].ptr);
    CHECK_GL_CALL(glCompressedTexSubImage3D)
        JT.glCompressedTexSubImage3D(param[0].uv32bit, param[1].v32bit, param[2].v32bit, param[3].v32bit, param[4].v32bit, param[5].v32bit, param[6].v32bit, param[7].v32bit, param[8].uv32bit, param[9].v32bit, (const GLvoid *)param[10].ptr);
}

void STUB_glCompressedTexSubImage3DARB( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glCompressedTexSubImage3DARB( GLenum, GLint, GLint, GLint, GLint, GLsizei, GLsizei, GLsizei, GLenum, GLsizei, const GLvoid * )
    maxParam = 11;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_PARAM(v32bit,1);
    READ_PARAM(v32bit,2);
    READ_PARAM(v32bit,3);
    READ_PARAM(v32bit,4);
    READ_PARAM(v32bit,5);
    READ_PARAM(v32bit,6);
    READ_PARAM(v32bit,7);
    READ_ENUM_PARAM(8);
    READ_PARAM(v32bit,9);
    READ_ARRAY_PARAM( 10, buffer0, TraceReader::TEXT_IGNORE);
    TR.skipLine();
    CHECK_USER_CALL(glCompressedTexSubImage3DARB)
        UCT.glCompressedTexSubImage3DARB(param[0].uv32bit, param[1].v32bit, param[2].v32bit, param[3].v32bit, param[4].v32bit, param[5].v32bit, param[6].v32bit, param[7].v32bit, param[8].uv32bit, param[9].v32bit, (const GLvoid *)param[10].ptr);
    CHECK_GL_CALL(glCompressedTexSubImage3DARB)
        JT.glCompressedTexSubImage3DARB(param[0].uv32bit, param[1].v32bit, param[2].v32bit, param[3].v32bit, param[4].v32bit, param[5].v32bit, param[6].v32bit, param[7].v32bit, param[8].uv32bit, param[9].v32bit, (const GLvoid *)param[10].ptr);
}

void STUB_glCompressedTextureImage1DEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glCompressedTextureImage1DEXT( GLuint, GLenum, GLint, GLenum, GLsizei, GLint, GLsizei, const GLvoid * )
    maxParam = 8;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_PARAM(v32bit,2);
    READ_ENUM_PARAM(3);
    READ_PARAM(v32bit,4);
    READ_PARAM(v32bit,5);
    READ_PARAM(v32bit,6);
    READ_ARRAY_PARAM( 7, buffer0, TraceReader::TEXT_IGNORE);
    TR.skipLine();
    CHECK_USER_CALL(glCompressedTextureImage1DEXT)
        UCT.glCompressedTextureImage1DEXT(param[0].uv32bit, param[1].uv32bit, param[2].v32bit, param[3].uv32bit, param[4].v32bit, param[5].v32bit, param[6].v32bit, (const GLvoid *)param[7].ptr);
    CHECK_GL_CALL(glCompressedTextureImage1DEXT)
        JT.glCompressedTextureImage1DEXT(param[0].uv32bit, param[1].uv32bit, param[2].v32bit, param[3].uv32bit, param[4].v32bit, param[5].v32bit, param[6].v32bit, (const GLvoid *)param[7].ptr);
}

void STUB_glCompressedTextureImage2DEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glCompressedTextureImage2DEXT( GLuint, GLenum, GLint, GLenum, GLsizei, GLsizei, GLint, GLsizei, const GLvoid * )
    maxParam = 9;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_PARAM(v32bit,2);
    READ_ENUM_PARAM(3);
    READ_PARAM(v32bit,4);
    READ_PARAM(v32bit,5);
    READ_PARAM(v32bit,6);
    READ_PARAM(v32bit,7);
    READ_ARRAY_PARAM( 8, buffer0, TraceReader::TEXT_IGNORE);
    TR.skipLine();
    CHECK_USER_CALL(glCompressedTextureImage2DEXT)
        UCT.glCompressedTextureImage2DEXT(param[0].uv32bit, param[1].uv32bit, param[2].v32bit, param[3].uv32bit, param[4].v32bit, param[5].v32bit, param[6].v32bit, param[7].v32bit, (const GLvoid *)param[8].ptr);
    CHECK_GL_CALL(glCompressedTextureImage2DEXT)
        JT.glCompressedTextureImage2DEXT(param[0].uv32bit, param[1].uv32bit, param[2].v32bit, param[3].uv32bit, param[4].v32bit, param[5].v32bit, param[6].v32bit, param[7].v32bit, (const GLvoid *)param[8].ptr);
}

void STUB_glCompressedTextureImage3DEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glCompressedTextureImage3DEXT( GLuint, GLenum, GLint, GLenum, GLsizei, GLsizei, GLsizei, GLint, GLsizei, const GLvoid * )
    maxParam = 10;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_PARAM(v32bit,2);
    READ_ENUM_PARAM(3);
    READ_PARAM(v32bit,4);
    READ_PARAM(v32bit,5);
    READ_PARAM(v32bit,6);
    READ_PARAM(v32bit,7);
    READ_PARAM(v32bit,8);
    READ_ARRAY_PARAM( 9, buffer0, TraceReader::TEXT_IGNORE);
    TR.skipLine();
    CHECK_USER_CALL(glCompressedTextureImage3DEXT)
        UCT.glCompressedTextureImage3DEXT(param[0].uv32bit, param[1].uv32bit, param[2].v32bit, param[3].uv32bit, param[4].v32bit, param[5].v32bit, param[6].v32bit, param[7].v32bit, param[8].v32bit, (const GLvoid *)param[9].ptr);
    CHECK_GL_CALL(glCompressedTextureImage3DEXT)
        JT.glCompressedTextureImage3DEXT(param[0].uv32bit, param[1].uv32bit, param[2].v32bit, param[3].uv32bit, param[4].v32bit, param[5].v32bit, param[6].v32bit, param[7].v32bit, param[8].v32bit, (const GLvoid *)param[9].ptr);
}

void STUB_glCompressedTextureSubImage1DEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glCompressedTextureSubImage1DEXT( GLuint, GLenum, GLint, GLint, GLsizei, GLenum, GLsizei, const GLvoid * )
    maxParam = 8;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_PARAM(v32bit,2);
    READ_PARAM(v32bit,3);
    READ_PARAM(v32bit,4);
    READ_ENUM_PARAM(5);
    READ_PARAM(v32bit,6);
    READ_ARRAY_PARAM( 7, buffer0, TraceReader::TEXT_IGNORE);
    TR.skipLine();
    CHECK_USER_CALL(glCompressedTextureSubImage1DEXT)
        UCT.glCompressedTextureSubImage1DEXT(param[0].uv32bit, param[1].uv32bit, param[2].v32bit, param[3].v32bit, param[4].v32bit, param[5].uv32bit, param[6].v32bit, (const GLvoid *)param[7].ptr);
    CHECK_GL_CALL(glCompressedTextureSubImage1DEXT)
        JT.glCompressedTextureSubImage1DEXT(param[0].uv32bit, param[1].uv32bit, param[2].v32bit, param[3].v32bit, param[4].v32bit, param[5].uv32bit, param[6].v32bit, (const GLvoid *)param[7].ptr);
}

void STUB_glCompressedTextureSubImage2DEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glCompressedTextureSubImage2DEXT( GLuint, GLenum, GLint, GLint, GLint, GLsizei, GLsizei, GLenum, GLsizei, const GLvoid * )
    maxParam = 10;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_PARAM(v32bit,2);
    READ_PARAM(v32bit,3);
    READ_PARAM(v32bit,4);
    READ_PARAM(v32bit,5);
    READ_PARAM(v32bit,6);
    READ_ENUM_PARAM(7);
    READ_PARAM(v32bit,8);
    READ_ARRAY_PARAM( 9, buffer0, TraceReader::TEXT_IGNORE);
    TR.skipLine();
    CHECK_USER_CALL(glCompressedTextureSubImage2DEXT)
        UCT.glCompressedTextureSubImage2DEXT(param[0].uv32bit, param[1].uv32bit, param[2].v32bit, param[3].v32bit, param[4].v32bit, param[5].v32bit, param[6].v32bit, param[7].uv32bit, param[8].v32bit, (const GLvoid *)param[9].ptr);
    CHECK_GL_CALL(glCompressedTextureSubImage2DEXT)
        JT.glCompressedTextureSubImage2DEXT(param[0].uv32bit, param[1].uv32bit, param[2].v32bit, param[3].v32bit, param[4].v32bit, param[5].v32bit, param[6].v32bit, param[7].uv32bit, param[8].v32bit, (const GLvoid *)param[9].ptr);
}

void STUB_glCompressedTextureSubImage3DEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glCompressedTextureSubImage3DEXT( GLuint, GLenum, GLint, GLint, GLint, GLint, GLsizei, GLsizei, GLsizei, GLenum, GLsizei, const GLvoid * )
    maxParam = 12;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_PARAM(v32bit,2);
    READ_PARAM(v32bit,3);
    READ_PARAM(v32bit,4);
    READ_PARAM(v32bit,5);
    READ_PARAM(v32bit,6);
    READ_PARAM(v32bit,7);
    READ_PARAM(v32bit,8);
    READ_ENUM_PARAM(9);
    READ_PARAM(v32bit,10);
    READ_ARRAY_PARAM( 11, buffer0, TraceReader::TEXT_IGNORE);
    TR.skipLine();
    CHECK_USER_CALL(glCompressedTextureSubImage3DEXT)
        UCT.glCompressedTextureSubImage3DEXT(param[0].uv32bit, param[1].uv32bit, param[2].v32bit, param[3].v32bit, param[4].v32bit, param[5].v32bit, param[6].v32bit, param[7].v32bit, param[8].v32bit, param[9].uv32bit, param[10].v32bit, (const GLvoid *)param[11].ptr);
    CHECK_GL_CALL(glCompressedTextureSubImage3DEXT)
        JT.glCompressedTextureSubImage3DEXT(param[0].uv32bit, param[1].uv32bit, param[2].v32bit, param[3].v32bit, param[4].v32bit, param[5].v32bit, param[6].v32bit, param[7].v32bit, param[8].v32bit, param[9].uv32bit, param[10].v32bit, (const GLvoid *)param[11].ptr);
}

void STUB_glConvolutionFilter1D( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glConvolutionFilter1D( GLenum target, GLenum internalformat, GLsizei width, GLenum format, GLenum type, const GLvoid *image )
    maxParam = 6;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_PARAM(v32bit,2);
    READ_ENUM_PARAM(3);
    READ_ENUM_PARAM(4);
    READ_ARRAY_PARAM( 5, buffer0, TraceReader::TEXT_IGNORE);
    TR.skipLine();
    CHECK_USER_CALL(glConvolutionFilter1D)
        UCT.glConvolutionFilter1D(param[0].uv32bit, param[1].uv32bit, param[2].v32bit, param[3].uv32bit, param[4].uv32bit, (const GLvoid *)param[5].ptr);
    CHECK_GL_CALL(glConvolutionFilter1D)
        JT.glConvolutionFilter1D(param[0].uv32bit, param[1].uv32bit, param[2].v32bit, param[3].uv32bit, param[4].uv32bit, (const GLvoid *)param[5].ptr);
}

void STUB_glConvolutionFilter1DEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glConvolutionFilter1DEXT( GLenum, GLenum, GLsizei, GLenum, GLenum, const GLvoid * )
    maxParam = 6;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_PARAM(v32bit,2);
    READ_ENUM_PARAM(3);
    READ_ENUM_PARAM(4);
    READ_ARRAY_PARAM( 5, buffer0, TraceReader::TEXT_IGNORE);
    TR.skipLine();
    CHECK_USER_CALL(glConvolutionFilter1DEXT)
        UCT.glConvolutionFilter1DEXT(param[0].uv32bit, param[1].uv32bit, param[2].v32bit, param[3].uv32bit, param[4].uv32bit, (const GLvoid *)param[5].ptr);
    CHECK_GL_CALL(glConvolutionFilter1DEXT)
        JT.glConvolutionFilter1DEXT(param[0].uv32bit, param[1].uv32bit, param[2].v32bit, param[3].uv32bit, param[4].uv32bit, (const GLvoid *)param[5].ptr);
}

void STUB_glConvolutionFilter2D( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glConvolutionFilter2D( GLenum target, GLenum internalformat, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *image )
    maxParam = 7;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_PARAM(v32bit,2);
    READ_PARAM(v32bit,3);
    READ_ENUM_PARAM(4);
    READ_ENUM_PARAM(5);
    READ_ARRAY_PARAM( 6, buffer0, TraceReader::TEXT_IGNORE);
    TR.skipLine();
    CHECK_USER_CALL(glConvolutionFilter2D)
        UCT.glConvolutionFilter2D(param[0].uv32bit, param[1].uv32bit, param[2].v32bit, param[3].v32bit, param[4].uv32bit, param[5].uv32bit, (const GLvoid *)param[6].ptr);
    CHECK_GL_CALL(glConvolutionFilter2D)
        JT.glConvolutionFilter2D(param[0].uv32bit, param[1].uv32bit, param[2].v32bit, param[3].v32bit, param[4].uv32bit, param[5].uv32bit, (const GLvoid *)param[6].ptr);
}

void STUB_glConvolutionFilter2DEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glConvolutionFilter2DEXT( GLenum, GLenum, GLsizei, GLsizei, GLenum, GLenum, const GLvoid * )
    maxParam = 7;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_PARAM(v32bit,2);
    READ_PARAM(v32bit,3);
    READ_ENUM_PARAM(4);
    READ_ENUM_PARAM(5);
    READ_ARRAY_PARAM( 6, buffer0, TraceReader::TEXT_IGNORE);
    TR.skipLine();
    CHECK_USER_CALL(glConvolutionFilter2DEXT)
        UCT.glConvolutionFilter2DEXT(param[0].uv32bit, param[1].uv32bit, param[2].v32bit, param[3].v32bit, param[4].uv32bit, param[5].uv32bit, (const GLvoid *)param[6].ptr);
    CHECK_GL_CALL(glConvolutionFilter2DEXT)
        JT.glConvolutionFilter2DEXT(param[0].uv32bit, param[1].uv32bit, param[2].v32bit, param[3].v32bit, param[4].uv32bit, param[5].uv32bit, (const GLvoid *)param[6].ptr);
}

void STUB_glConvolutionParameterf( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glConvolutionParameterf( GLenum target, GLenum pname, GLfloat params )
    maxParam = 3;
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_PARAM(fv32bit,2);
    TR.skipLine();
    CHECK_USER_CALL(glConvolutionParameterf)
        UCT.glConvolutionParameterf(param[0].uv32bit, param[1].uv32bit, param[2].fv32bit);
    CHECK_GL_CALL(glConvolutionParameterf)
        JT.glConvolutionParameterf(param[0].uv32bit, param[1].uv32bit, param[2].fv32bit);
}

void STUB_glConvolutionParameterfEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glConvolutionParameterfEXT( GLenum, GLenum, GLfloat )
    maxParam = 3;
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_PARAM(fv32bit,2);
    TR.skipLine();
    CHECK_USER_CALL(glConvolutionParameterfEXT)
        UCT.glConvolutionParameterfEXT(param[0].uv32bit, param[1].uv32bit, param[2].fv32bit);
    CHECK_GL_CALL(glConvolutionParameterfEXT)
        JT.glConvolutionParameterfEXT(param[0].uv32bit, param[1].uv32bit, param[2].fv32bit);
}

void STUB_glConvolutionParameterfv( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glConvolutionParameterfv( GLenum target, GLenum pname, const GLfloat *params )
    maxParam = 3;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_ARRAY_PARAM( 2, buffer0, TraceReader::TEXT_FLOAT);
    TR.skipLine();
    CHECK_USER_CALL(glConvolutionParameterfv)
        UCT.glConvolutionParameterfv(param[0].uv32bit, param[1].uv32bit, (const GLfloat *)param[2].ptr);
    CHECK_GL_CALL(glConvolutionParameterfv)
        JT.glConvolutionParameterfv(param[0].uv32bit, param[1].uv32bit, (const GLfloat *)param[2].ptr);
}

void STUB_glConvolutionParameterfvEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glConvolutionParameterfvEXT( GLenum, GLenum, const GLfloat * )
    maxParam = 3;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_ARRAY_PARAM( 2, buffer0, TraceReader::TEXT_FLOAT);
    TR.skipLine();
    CHECK_USER_CALL(glConvolutionParameterfvEXT)
        UCT.glConvolutionParameterfvEXT(param[0].uv32bit, param[1].uv32bit, (const GLfloat *)param[2].ptr);
    CHECK_GL_CALL(glConvolutionParameterfvEXT)
        JT.glConvolutionParameterfvEXT(param[0].uv32bit, param[1].uv32bit, (const GLfloat *)param[2].ptr);
}

void STUB_glConvolutionParameteri( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glConvolutionParameteri( GLenum target, GLenum pname, GLint params )
    maxParam = 3;
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_PARAM(v32bit,2);
    TR.skipLine();
    CHECK_USER_CALL(glConvolutionParameteri)
        UCT.glConvolutionParameteri(param[0].uv32bit, param[1].uv32bit, param[2].v32bit);
    CHECK_GL_CALL(glConvolutionParameteri)
        JT.glConvolutionParameteri(param[0].uv32bit, param[1].uv32bit, param[2].v32bit);
}

void STUB_glConvolutionParameteriEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glConvolutionParameteriEXT( GLenum, GLenum, GLint )
    maxParam = 3;
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_PARAM(v32bit,2);
    TR.skipLine();
    CHECK_USER_CALL(glConvolutionParameteriEXT)
        UCT.glConvolutionParameteriEXT(param[0].uv32bit, param[1].uv32bit, param[2].v32bit);
    CHECK_GL_CALL(glConvolutionParameteriEXT)
        JT.glConvolutionParameteriEXT(param[0].uv32bit, param[1].uv32bit, param[2].v32bit);
}

void STUB_glConvolutionParameteriv( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glConvolutionParameteriv( GLenum target, GLenum pname, const GLint *params )
    maxParam = 3;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_ARRAY_PARAM( 2, buffer0, TraceReader::TEXT_INT);
    TR.skipLine();
    CHECK_USER_CALL(glConvolutionParameteriv)
        UCT.glConvolutionParameteriv(param[0].uv32bit, param[1].uv32bit, (const GLint *)param[2].ptr);
    CHECK_GL_CALL(glConvolutionParameteriv)
        JT.glConvolutionParameteriv(param[0].uv32bit, param[1].uv32bit, (const GLint *)param[2].ptr);
}

void STUB_glConvolutionParameterivEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glConvolutionParameterivEXT( GLenum, GLenum, const GLint * )
    maxParam = 3;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_ARRAY_PARAM( 2, buffer0, TraceReader::TEXT_INT);
    TR.skipLine();
    CHECK_USER_CALL(glConvolutionParameterivEXT)
        UCT.glConvolutionParameterivEXT(param[0].uv32bit, param[1].uv32bit, (const GLint *)param[2].ptr);
    CHECK_GL_CALL(glConvolutionParameterivEXT)
        JT.glConvolutionParameterivEXT(param[0].uv32bit, param[1].uv32bit, (const GLint *)param[2].ptr);
}

void STUB_glCopyBufferSubData( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glCopyBufferSubData( GLenum, GLenum, GLintptr, GLintptr, GLsizeiptr )
    maxParam = 5;
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_PARAM(v32bit,2);
    READ_PARAM(v32bit,3);
    READ_PARAM(v32bit,4);
    TR.skipLine();
    CHECK_USER_CALL(glCopyBufferSubData)
        UCT.glCopyBufferSubData(param[0].uv32bit, param[1].uv32bit, param[2].v32bit, param[3].v32bit, param[4].v32bit);
    CHECK_GL_CALL(glCopyBufferSubData)
        JT.glCopyBufferSubData(param[0].uv32bit, param[1].uv32bit, param[2].v32bit, param[3].v32bit, param[4].v32bit);
}

void STUB_glCopyColorSubTable( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glCopyColorSubTable( GLenum target, GLsizei start, GLint x, GLint y, GLsizei width )
    maxParam = 5;
    READ_ENUM_PARAM(0);
    READ_PARAM(v32bit,1);
    READ_PARAM(v32bit,2);
    READ_PARAM(v32bit,3);
    READ_PARAM(v32bit,4);
    TR.skipLine();
    CHECK_USER_CALL(glCopyColorSubTable)
        UCT.glCopyColorSubTable(param[0].uv32bit, param[1].v32bit, param[2].v32bit, param[3].v32bit, param[4].v32bit);
    CHECK_GL_CALL(glCopyColorSubTable)
        JT.glCopyColorSubTable(param[0].uv32bit, param[1].v32bit, param[2].v32bit, param[3].v32bit, param[4].v32bit);
}

void STUB_glCopyColorSubTableEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glCopyColorSubTableEXT( GLenum, GLsizei, GLint, GLint, GLsizei )
    maxParam = 5;
    READ_ENUM_PARAM(0);
    READ_PARAM(v32bit,1);
    READ_PARAM(v32bit,2);
    READ_PARAM(v32bit,3);
    READ_PARAM(v32bit,4);
    TR.skipLine();
    CHECK_USER_CALL(glCopyColorSubTableEXT)
        UCT.glCopyColorSubTableEXT(param[0].uv32bit, param[1].v32bit, param[2].v32bit, param[3].v32bit, param[4].v32bit);
    CHECK_GL_CALL(glCopyColorSubTableEXT)
        JT.glCopyColorSubTableEXT(param[0].uv32bit, param[1].v32bit, param[2].v32bit, param[3].v32bit, param[4].v32bit);
}

void STUB_glCopyColorTable( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glCopyColorTable( GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width )
    maxParam = 5;
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_PARAM(v32bit,2);
    READ_PARAM(v32bit,3);
    READ_PARAM(v32bit,4);
    TR.skipLine();
    CHECK_USER_CALL(glCopyColorTable)
        UCT.glCopyColorTable(param[0].uv32bit, param[1].uv32bit, param[2].v32bit, param[3].v32bit, param[4].v32bit);
    CHECK_GL_CALL(glCopyColorTable)
        JT.glCopyColorTable(param[0].uv32bit, param[1].uv32bit, param[2].v32bit, param[3].v32bit, param[4].v32bit);
}

void STUB_glCopyColorTableSGI( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glCopyColorTableSGI( GLenum, GLenum, GLint, GLint, GLsizei )
    maxParam = 5;
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_PARAM(v32bit,2);
    READ_PARAM(v32bit,3);
    READ_PARAM(v32bit,4);
    TR.skipLine();
    CHECK_USER_CALL(glCopyColorTableSGI)
        UCT.glCopyColorTableSGI(param[0].uv32bit, param[1].uv32bit, param[2].v32bit, param[3].v32bit, param[4].v32bit);
    CHECK_GL_CALL(glCopyColorTableSGI)
        JT.glCopyColorTableSGI(param[0].uv32bit, param[1].uv32bit, param[2].v32bit, param[3].v32bit, param[4].v32bit);
}

void STUB_glCopyConvolutionFilter1D( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glCopyConvolutionFilter1D( GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width )
    maxParam = 5;
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_PARAM(v32bit,2);
    READ_PARAM(v32bit,3);
    READ_PARAM(v32bit,4);
    TR.skipLine();
    CHECK_USER_CALL(glCopyConvolutionFilter1D)
        UCT.glCopyConvolutionFilter1D(param[0].uv32bit, param[1].uv32bit, param[2].v32bit, param[3].v32bit, param[4].v32bit);
    CHECK_GL_CALL(glCopyConvolutionFilter1D)
        JT.glCopyConvolutionFilter1D(param[0].uv32bit, param[1].uv32bit, param[2].v32bit, param[3].v32bit, param[4].v32bit);
}

void STUB_glCopyConvolutionFilter1DEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glCopyConvolutionFilter1DEXT( GLenum, GLenum, GLint, GLint, GLsizei )
    maxParam = 5;
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_PARAM(v32bit,2);
    READ_PARAM(v32bit,3);
    READ_PARAM(v32bit,4);
    TR.skipLine();
    CHECK_USER_CALL(glCopyConvolutionFilter1DEXT)
        UCT.glCopyConvolutionFilter1DEXT(param[0].uv32bit, param[1].uv32bit, param[2].v32bit, param[3].v32bit, param[4].v32bit);
    CHECK_GL_CALL(glCopyConvolutionFilter1DEXT)
        JT.glCopyConvolutionFilter1DEXT(param[0].uv32bit, param[1].uv32bit, param[2].v32bit, param[3].v32bit, param[4].v32bit);
}

void STUB_glCopyConvolutionFilter2D( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glCopyConvolutionFilter2D( GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height )
    maxParam = 6;
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_PARAM(v32bit,2);
    READ_PARAM(v32bit,3);
    READ_PARAM(v32bit,4);
    READ_PARAM(v32bit,5);
    TR.skipLine();
    CHECK_USER_CALL(glCopyConvolutionFilter2D)
        UCT.glCopyConvolutionFilter2D(param[0].uv32bit, param[1].uv32bit, param[2].v32bit, param[3].v32bit, param[4].v32bit, param[5].v32bit);
    CHECK_GL_CALL(glCopyConvolutionFilter2D)
        JT.glCopyConvolutionFilter2D(param[0].uv32bit, param[1].uv32bit, param[2].v32bit, param[3].v32bit, param[4].v32bit, param[5].v32bit);
}

void STUB_glCopyConvolutionFilter2DEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glCopyConvolutionFilter2DEXT( GLenum, GLenum, GLint, GLint, GLsizei, GLsizei )
    maxParam = 6;
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_PARAM(v32bit,2);
    READ_PARAM(v32bit,3);
    READ_PARAM(v32bit,4);
    READ_PARAM(v32bit,5);
    TR.skipLine();
    CHECK_USER_CALL(glCopyConvolutionFilter2DEXT)
        UCT.glCopyConvolutionFilter2DEXT(param[0].uv32bit, param[1].uv32bit, param[2].v32bit, param[3].v32bit, param[4].v32bit, param[5].v32bit);
    CHECK_GL_CALL(glCopyConvolutionFilter2DEXT)
        JT.glCopyConvolutionFilter2DEXT(param[0].uv32bit, param[1].uv32bit, param[2].v32bit, param[3].v32bit, param[4].v32bit, param[5].v32bit);
}

void STUB_glCopyMultiTexImage1DEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glCopyMultiTexImage1DEXT( GLenum, GLenum, GLint, GLenum, GLint, GLint, GLsizei, GLint )
    maxParam = 8;
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_PARAM(v32bit,2);
    READ_ENUM_PARAM(3);
    READ_PARAM(v32bit,4);
    READ_PARAM(v32bit,5);
    READ_PARAM(v32bit,6);
    READ_PARAM(v32bit,7);
    TR.skipLine();
    CHECK_USER_CALL(glCopyMultiTexImage1DEXT)
        UCT.glCopyMultiTexImage1DEXT(param[0].uv32bit, param[1].uv32bit, param[2].v32bit, param[3].uv32bit, param[4].v32bit, param[5].v32bit, param[6].v32bit, param[7].v32bit);
    CHECK_GL_CALL(glCopyMultiTexImage1DEXT)
        JT.glCopyMultiTexImage1DEXT(param[0].uv32bit, param[1].uv32bit, param[2].v32bit, param[3].uv32bit, param[4].v32bit, param[5].v32bit, param[6].v32bit, param[7].v32bit);
}

void STUB_glCopyMultiTexImage2DEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glCopyMultiTexImage2DEXT( GLenum, GLenum, GLint, GLenum, GLint, GLint, GLsizei, GLsizei, GLint )
    maxParam = 9;
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_PARAM(v32bit,2);
    READ_ENUM_PARAM(3);
    READ_PARAM(v32bit,4);
    READ_PARAM(v32bit,5);
    READ_PARAM(v32bit,6);
    READ_PARAM(v32bit,7);
    READ_PARAM(v32bit,8);
    TR.skipLine();
    CHECK_USER_CALL(glCopyMultiTexImage2DEXT)
        UCT.glCopyMultiTexImage2DEXT(param[0].uv32bit, param[1].uv32bit, param[2].v32bit, param[3].uv32bit, param[4].v32bit, param[5].v32bit, param[6].v32bit, param[7].v32bit, param[8].v32bit);
    CHECK_GL_CALL(glCopyMultiTexImage2DEXT)
        JT.glCopyMultiTexImage2DEXT(param[0].uv32bit, param[1].uv32bit, param[2].v32bit, param[3].uv32bit, param[4].v32bit, param[5].v32bit, param[6].v32bit, param[7].v32bit, param[8].v32bit);
}

void STUB_glCopyMultiTexSubImage1DEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glCopyMultiTexSubImage1DEXT( GLenum, GLenum, GLint, GLint, GLint, GLint, GLsizei )
    maxParam = 7;
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_PARAM(v32bit,2);
    READ_PARAM(v32bit,3);
    READ_PARAM(v32bit,4);
    READ_PARAM(v32bit,5);
    READ_PARAM(v32bit,6);
    TR.skipLine();
    CHECK_USER_CALL(glCopyMultiTexSubImage1DEXT)
        UCT.glCopyMultiTexSubImage1DEXT(param[0].uv32bit, param[1].uv32bit, param[2].v32bit, param[3].v32bit, param[4].v32bit, param[5].v32bit, param[6].v32bit);
    CHECK_GL_CALL(glCopyMultiTexSubImage1DEXT)
        JT.glCopyMultiTexSubImage1DEXT(param[0].uv32bit, param[1].uv32bit, param[2].v32bit, param[3].v32bit, param[4].v32bit, param[5].v32bit, param[6].v32bit);
}

void STUB_glCopyMultiTexSubImage2DEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glCopyMultiTexSubImage2DEXT( GLenum, GLenum, GLint, GLint, GLint, GLint, GLint, GLsizei, GLsizei )
    maxParam = 9;
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_PARAM(v32bit,2);
    READ_PARAM(v32bit,3);
    READ_PARAM(v32bit,4);
    READ_PARAM(v32bit,5);
    READ_PARAM(v32bit,6);
    READ_PARAM(v32bit,7);
    READ_PARAM(v32bit,8);
    TR.skipLine();
    CHECK_USER_CALL(glCopyMultiTexSubImage2DEXT)
        UCT.glCopyMultiTexSubImage2DEXT(param[0].uv32bit, param[1].uv32bit, param[2].v32bit, param[3].v32bit, param[4].v32bit, param[5].v32bit, param[6].v32bit, param[7].v32bit, param[8].v32bit);
    CHECK_GL_CALL(glCopyMultiTexSubImage2DEXT)
        JT.glCopyMultiTexSubImage2DEXT(param[0].uv32bit, param[1].uv32bit, param[2].v32bit, param[3].v32bit, param[4].v32bit, param[5].v32bit, param[6].v32bit, param[7].v32bit, param[8].v32bit);
}

void STUB_glCopyMultiTexSubImage3DEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glCopyMultiTexSubImage3DEXT( GLenum, GLenum, GLint, GLint, GLint, GLint, GLint, GLint, GLsizei, GLsizei )
    maxParam = 10;
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_PARAM(v32bit,2);
    READ_PARAM(v32bit,3);
    READ_PARAM(v32bit,4);
    READ_PARAM(v32bit,5);
    READ_PARAM(v32bit,6);
    READ_PARAM(v32bit,7);
    READ_PARAM(v32bit,8);
    READ_PARAM(v32bit,9);
    TR.skipLine();
    CHECK_USER_CALL(glCopyMultiTexSubImage3DEXT)
        UCT.glCopyMultiTexSubImage3DEXT(param[0].uv32bit, param[1].uv32bit, param[2].v32bit, param[3].v32bit, param[4].v32bit, param[5].v32bit, param[6].v32bit, param[7].v32bit, param[8].v32bit, param[9].v32bit);
    CHECK_GL_CALL(glCopyMultiTexSubImage3DEXT)
        JT.glCopyMultiTexSubImage3DEXT(param[0].uv32bit, param[1].uv32bit, param[2].v32bit, param[3].v32bit, param[4].v32bit, param[5].v32bit, param[6].v32bit, param[7].v32bit, param[8].v32bit, param[9].v32bit);
}

void STUB_glCopyPixels( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glCopyPixels( GLint x, GLint y, GLsizei width, GLsizei height, GLenum type )
    maxParam = 5;
    READ_PARAM(v32bit,0);
    READ_PARAM(v32bit,1);
    READ_PARAM(v32bit,2);
    READ_PARAM(v32bit,3);
    READ_ENUM_PARAM(4);
    TR.skipLine();
    CHECK_USER_CALL(glCopyPixels)
        UCT.glCopyPixels(param[0].v32bit, param[1].v32bit, param[2].v32bit, param[3].v32bit, param[4].uv32bit);
    CHECK_GL_CALL(glCopyPixels)
        JT.glCopyPixels(param[0].v32bit, param[1].v32bit, param[2].v32bit, param[3].v32bit, param[4].uv32bit);
}

void STUB_glCopyTexImage1D( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glCopyTexImage1D( GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLint border )
    maxParam = 7;
    READ_ENUM_PARAM(0);
    READ_PARAM(v32bit,1);
    READ_ENUM_PARAM(2);
    READ_PARAM(v32bit,3);
    READ_PARAM(v32bit,4);
    READ_PARAM(v32bit,5);
    READ_PARAM(v32bit,6);
    TR.skipLine();
    CHECK_USER_CALL(glCopyTexImage1D)
        UCT.glCopyTexImage1D(param[0].uv32bit, param[1].v32bit, param[2].uv32bit, param[3].v32bit, param[4].v32bit, param[5].v32bit, param[6].v32bit);
    CHECK_GL_CALL(glCopyTexImage1D)
        JT.glCopyTexImage1D(param[0].uv32bit, param[1].v32bit, param[2].uv32bit, param[3].v32bit, param[4].v32bit, param[5].v32bit, param[6].v32bit);
}

void STUB_glCopyTexImage1DEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glCopyTexImage1DEXT( GLenum, GLint, GLenum, GLint, GLint, GLsizei, GLint )
    maxParam = 7;
    READ_ENUM_PARAM(0);
    READ_PARAM(v32bit,1);
    READ_ENUM_PARAM(2);
    READ_PARAM(v32bit,3);
    READ_PARAM(v32bit,4);
    READ_PARAM(v32bit,5);
    READ_PARAM(v32bit,6);
    TR.skipLine();
    CHECK_USER_CALL(glCopyTexImage1DEXT)
        UCT.glCopyTexImage1DEXT(param[0].uv32bit, param[1].v32bit, param[2].uv32bit, param[3].v32bit, param[4].v32bit, param[5].v32bit, param[6].v32bit);
    CHECK_GL_CALL(glCopyTexImage1DEXT)
        JT.glCopyTexImage1DEXT(param[0].uv32bit, param[1].v32bit, param[2].uv32bit, param[3].v32bit, param[4].v32bit, param[5].v32bit, param[6].v32bit);
}

void STUB_glCopyTexImage2D( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glCopyTexImage2D( GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border )
    maxParam = 8;
    READ_ENUM_PARAM(0);
    READ_PARAM(v32bit,1);
    READ_ENUM_PARAM(2);
    READ_PARAM(v32bit,3);
    READ_PARAM(v32bit,4);
    READ_PARAM(v32bit,5);
    READ_PARAM(v32bit,6);
    READ_PARAM(v32bit,7);
    TR.skipLine();
    CHECK_USER_CALL(glCopyTexImage2D)
        UCT.glCopyTexImage2D(param[0].uv32bit, param[1].v32bit, param[2].uv32bit, param[3].v32bit, param[4].v32bit, param[5].v32bit, param[6].v32bit, param[7].v32bit);
    CHECK_GL_CALL(glCopyTexImage2D)
        JT.glCopyTexImage2D(param[0].uv32bit, param[1].v32bit, param[2].uv32bit, param[3].v32bit, param[4].v32bit, param[5].v32bit, param[6].v32bit, param[7].v32bit);
}

void STUB_glCopyTexImage2DEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glCopyTexImage2DEXT( GLenum, GLint, GLenum, GLint, GLint, GLsizei, GLsizei, GLint )
    maxParam = 8;
    READ_ENUM_PARAM(0);
    READ_PARAM(v32bit,1);
    READ_ENUM_PARAM(2);
    READ_PARAM(v32bit,3);
    READ_PARAM(v32bit,4);
    READ_PARAM(v32bit,5);
    READ_PARAM(v32bit,6);
    READ_PARAM(v32bit,7);
    TR.skipLine();
    CHECK_USER_CALL(glCopyTexImage2DEXT)
        UCT.glCopyTexImage2DEXT(param[0].uv32bit, param[1].v32bit, param[2].uv32bit, param[3].v32bit, param[4].v32bit, param[5].v32bit, param[6].v32bit, param[7].v32bit);
    CHECK_GL_CALL(glCopyTexImage2DEXT)
        JT.glCopyTexImage2DEXT(param[0].uv32bit, param[1].v32bit, param[2].uv32bit, param[3].v32bit, param[4].v32bit, param[5].v32bit, param[6].v32bit, param[7].v32bit);
}

void STUB_glCopyTexSubImage1D( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glCopyTexSubImage1D( GLenum target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width )
    maxParam = 6;
    READ_ENUM_PARAM(0);
    READ_PARAM(v32bit,1);
    READ_PARAM(v32bit,2);
    READ_PARAM(v32bit,3);
    READ_PARAM(v32bit,4);
    READ_PARAM(v32bit,5);
    TR.skipLine();
    CHECK_USER_CALL(glCopyTexSubImage1D)
        UCT.glCopyTexSubImage1D(param[0].uv32bit, param[1].v32bit, param[2].v32bit, param[3].v32bit, param[4].v32bit, param[5].v32bit);
    CHECK_GL_CALL(glCopyTexSubImage1D)
        JT.glCopyTexSubImage1D(param[0].uv32bit, param[1].v32bit, param[2].v32bit, param[3].v32bit, param[4].v32bit, param[5].v32bit);
}

void STUB_glCopyTexSubImage1DEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glCopyTexSubImage1DEXT( GLenum, GLint, GLint, GLint, GLint, GLsizei )
    maxParam = 6;
    READ_ENUM_PARAM(0);
    READ_PARAM(v32bit,1);
    READ_PARAM(v32bit,2);
    READ_PARAM(v32bit,3);
    READ_PARAM(v32bit,4);
    READ_PARAM(v32bit,5);
    TR.skipLine();
    CHECK_USER_CALL(glCopyTexSubImage1DEXT)
        UCT.glCopyTexSubImage1DEXT(param[0].uv32bit, param[1].v32bit, param[2].v32bit, param[3].v32bit, param[4].v32bit, param[5].v32bit);
    CHECK_GL_CALL(glCopyTexSubImage1DEXT)
        JT.glCopyTexSubImage1DEXT(param[0].uv32bit, param[1].v32bit, param[2].v32bit, param[3].v32bit, param[4].v32bit, param[5].v32bit);
}

void STUB_glCopyTexSubImage2D( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glCopyTexSubImage2D( GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height )
    maxParam = 8;
    READ_ENUM_PARAM(0);
    READ_PARAM(v32bit,1);
    READ_PARAM(v32bit,2);
    READ_PARAM(v32bit,3);
    READ_PARAM(v32bit,4);
    READ_PARAM(v32bit,5);
    READ_PARAM(v32bit,6);
    READ_PARAM(v32bit,7);
    TR.skipLine();
    CHECK_USER_CALL(glCopyTexSubImage2D)
        UCT.glCopyTexSubImage2D(param[0].uv32bit, param[1].v32bit, param[2].v32bit, param[3].v32bit, param[4].v32bit, param[5].v32bit, param[6].v32bit, param[7].v32bit);
    CHECK_GL_CALL(glCopyTexSubImage2D)
        JT.glCopyTexSubImage2D(param[0].uv32bit, param[1].v32bit, param[2].v32bit, param[3].v32bit, param[4].v32bit, param[5].v32bit, param[6].v32bit, param[7].v32bit);
}

void STUB_glCopyTexSubImage2DEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glCopyTexSubImage2DEXT( GLenum, GLint, GLint, GLint, GLint, GLint, GLsizei, GLsizei )
    maxParam = 8;
    READ_ENUM_PARAM(0);
    READ_PARAM(v32bit,1);
    READ_PARAM(v32bit,2);
    READ_PARAM(v32bit,3);
    READ_PARAM(v32bit,4);
    READ_PARAM(v32bit,5);
    READ_PARAM(v32bit,6);
    READ_PARAM(v32bit,7);
    TR.skipLine();
    CHECK_USER_CALL(glCopyTexSubImage2DEXT)
        UCT.glCopyTexSubImage2DEXT(param[0].uv32bit, param[1].v32bit, param[2].v32bit, param[3].v32bit, param[4].v32bit, param[5].v32bit, param[6].v32bit, param[7].v32bit);
    CHECK_GL_CALL(glCopyTexSubImage2DEXT)
        JT.glCopyTexSubImage2DEXT(param[0].uv32bit, param[1].v32bit, param[2].v32bit, param[3].v32bit, param[4].v32bit, param[5].v32bit, param[6].v32bit, param[7].v32bit);
}

void STUB_glCopyTexSubImage3D( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glCopyTexSubImage3D( GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height )
    maxParam = 9;
    READ_ENUM_PARAM(0);
    READ_PARAM(v32bit,1);
    READ_PARAM(v32bit,2);
    READ_PARAM(v32bit,3);
    READ_PARAM(v32bit,4);
    READ_PARAM(v32bit,5);
    READ_PARAM(v32bit,6);
    READ_PARAM(v32bit,7);
    READ_PARAM(v32bit,8);
    TR.skipLine();
    CHECK_USER_CALL(glCopyTexSubImage3D)
        UCT.glCopyTexSubImage3D(param[0].uv32bit, param[1].v32bit, param[2].v32bit, param[3].v32bit, param[4].v32bit, param[5].v32bit, param[6].v32bit, param[7].v32bit, param[8].v32bit);
    CHECK_GL_CALL(glCopyTexSubImage3D)
        JT.glCopyTexSubImage3D(param[0].uv32bit, param[1].v32bit, param[2].v32bit, param[3].v32bit, param[4].v32bit, param[5].v32bit, param[6].v32bit, param[7].v32bit, param[8].v32bit);
}

void STUB_glCopyTexSubImage3DEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glCopyTexSubImage3DEXT( GLenum, GLint, GLint, GLint, GLint, GLint, GLint, GLsizei, GLsizei )
    maxParam = 9;
    READ_ENUM_PARAM(0);
    READ_PARAM(v32bit,1);
    READ_PARAM(v32bit,2);
    READ_PARAM(v32bit,3);
    READ_PARAM(v32bit,4);
    READ_PARAM(v32bit,5);
    READ_PARAM(v32bit,6);
    READ_PARAM(v32bit,7);
    READ_PARAM(v32bit,8);
    TR.skipLine();
    CHECK_USER_CALL(glCopyTexSubImage3DEXT)
        UCT.glCopyTexSubImage3DEXT(param[0].uv32bit, param[1].v32bit, param[2].v32bit, param[3].v32bit, param[4].v32bit, param[5].v32bit, param[6].v32bit, param[7].v32bit, param[8].v32bit);
    CHECK_GL_CALL(glCopyTexSubImage3DEXT)
        JT.glCopyTexSubImage3DEXT(param[0].uv32bit, param[1].v32bit, param[2].v32bit, param[3].v32bit, param[4].v32bit, param[5].v32bit, param[6].v32bit, param[7].v32bit, param[8].v32bit);
}

void STUB_glCopyTextureImage1DEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glCopyTextureImage1DEXT( GLuint, GLenum, GLint, GLenum, GLint, GLint, GLsizei, GLint )
    maxParam = 8;
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_PARAM(v32bit,2);
    READ_ENUM_PARAM(3);
    READ_PARAM(v32bit,4);
    READ_PARAM(v32bit,5);
    READ_PARAM(v32bit,6);
    READ_PARAM(v32bit,7);
    TR.skipLine();
    CHECK_USER_CALL(glCopyTextureImage1DEXT)
        UCT.glCopyTextureImage1DEXT(param[0].uv32bit, param[1].uv32bit, param[2].v32bit, param[3].uv32bit, param[4].v32bit, param[5].v32bit, param[6].v32bit, param[7].v32bit);
    CHECK_GL_CALL(glCopyTextureImage1DEXT)
        JT.glCopyTextureImage1DEXT(param[0].uv32bit, param[1].uv32bit, param[2].v32bit, param[3].uv32bit, param[4].v32bit, param[5].v32bit, param[6].v32bit, param[7].v32bit);
}

void STUB_glCopyTextureImage2DEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glCopyTextureImage2DEXT( GLuint, GLenum, GLint, GLenum, GLint, GLint, GLsizei, GLsizei, GLint )
    maxParam = 9;
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_PARAM(v32bit,2);
    READ_ENUM_PARAM(3);
    READ_PARAM(v32bit,4);
    READ_PARAM(v32bit,5);
    READ_PARAM(v32bit,6);
    READ_PARAM(v32bit,7);
    READ_PARAM(v32bit,8);
    TR.skipLine();
    CHECK_USER_CALL(glCopyTextureImage2DEXT)
        UCT.glCopyTextureImage2DEXT(param[0].uv32bit, param[1].uv32bit, param[2].v32bit, param[3].uv32bit, param[4].v32bit, param[5].v32bit, param[6].v32bit, param[7].v32bit, param[8].v32bit);
    CHECK_GL_CALL(glCopyTextureImage2DEXT)
        JT.glCopyTextureImage2DEXT(param[0].uv32bit, param[1].uv32bit, param[2].v32bit, param[3].uv32bit, param[4].v32bit, param[5].v32bit, param[6].v32bit, param[7].v32bit, param[8].v32bit);
}

void STUB_glCopyTextureSubImage1DEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glCopyTextureSubImage1DEXT( GLuint, GLenum, GLint, GLint, GLint, GLint, GLsizei )
    maxParam = 7;
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_PARAM(v32bit,2);
    READ_PARAM(v32bit,3);
    READ_PARAM(v32bit,4);
    READ_PARAM(v32bit,5);
    READ_PARAM(v32bit,6);
    TR.skipLine();
    CHECK_USER_CALL(glCopyTextureSubImage1DEXT)
        UCT.glCopyTextureSubImage1DEXT(param[0].uv32bit, param[1].uv32bit, param[2].v32bit, param[3].v32bit, param[4].v32bit, param[5].v32bit, param[6].v32bit);
    CHECK_GL_CALL(glCopyTextureSubImage1DEXT)
        JT.glCopyTextureSubImage1DEXT(param[0].uv32bit, param[1].uv32bit, param[2].v32bit, param[3].v32bit, param[4].v32bit, param[5].v32bit, param[6].v32bit);
}

void STUB_glCopyTextureSubImage2DEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glCopyTextureSubImage2DEXT( GLuint, GLenum, GLint, GLint, GLint, GLint, GLint, GLsizei, GLsizei )
    maxParam = 9;
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_PARAM(v32bit,2);
    READ_PARAM(v32bit,3);
    READ_PARAM(v32bit,4);
    READ_PARAM(v32bit,5);
    READ_PARAM(v32bit,6);
    READ_PARAM(v32bit,7);
    READ_PARAM(v32bit,8);
    TR.skipLine();
    CHECK_USER_CALL(glCopyTextureSubImage2DEXT)
        UCT.glCopyTextureSubImage2DEXT(param[0].uv32bit, param[1].uv32bit, param[2].v32bit, param[3].v32bit, param[4].v32bit, param[5].v32bit, param[6].v32bit, param[7].v32bit, param[8].v32bit);
    CHECK_GL_CALL(glCopyTextureSubImage2DEXT)
        JT.glCopyTextureSubImage2DEXT(param[0].uv32bit, param[1].uv32bit, param[2].v32bit, param[3].v32bit, param[4].v32bit, param[5].v32bit, param[6].v32bit, param[7].v32bit, param[8].v32bit);
}

void STUB_glCopyTextureSubImage3DEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glCopyTextureSubImage3DEXT( GLuint, GLenum, GLint, GLint, GLint, GLint, GLint, GLint, GLsizei, GLsizei )
    maxParam = 10;
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_PARAM(v32bit,2);
    READ_PARAM(v32bit,3);
    READ_PARAM(v32bit,4);
    READ_PARAM(v32bit,5);
    READ_PARAM(v32bit,6);
    READ_PARAM(v32bit,7);
    READ_PARAM(v32bit,8);
    READ_PARAM(v32bit,9);
    TR.skipLine();
    CHECK_USER_CALL(glCopyTextureSubImage3DEXT)
        UCT.glCopyTextureSubImage3DEXT(param[0].uv32bit, param[1].uv32bit, param[2].v32bit, param[3].v32bit, param[4].v32bit, param[5].v32bit, param[6].v32bit, param[7].v32bit, param[8].v32bit, param[9].v32bit);
    CHECK_GL_CALL(glCopyTextureSubImage3DEXT)
        JT.glCopyTextureSubImage3DEXT(param[0].uv32bit, param[1].uv32bit, param[2].v32bit, param[3].v32bit, param[4].v32bit, param[5].v32bit, param[6].v32bit, param[7].v32bit, param[8].v32bit, param[9].v32bit);
}

void STUB_glCreateProgram( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // GLuint glCreateProgram(  )
    maxParam = 0;
    TR.skipResult();
    TR.skipLine();
    CHECK_USER_CALL(glCreateProgram)
        UCT.glCreateProgram();
    CHECK_GL_CALL(glCreateProgram)
        JT.glCreateProgram();
}

void STUB_glCreateProgramObjectARB( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // GLhandleARB glCreateProgramObjectARB(  )
    maxParam = 0;
    TR.skipResult();
    TR.skipLine();
    CHECK_USER_CALL(glCreateProgramObjectARB)
        UCT.glCreateProgramObjectARB();
    CHECK_GL_CALL(glCreateProgramObjectARB)
        JT.glCreateProgramObjectARB();
}

void STUB_glCreateShader( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // GLuint glCreateShader( GLenum )
    maxParam = 1;
    READ_ENUM_PARAM(0);
    TR.skipResult();
    TR.skipLine();
    CHECK_USER_CALL(glCreateShader)
        UCT.glCreateShader(param[0].uv32bit);
    CHECK_GL_CALL(glCreateShader)
        JT.glCreateShader(param[0].uv32bit);
}

void STUB_glCreateShaderObjectARB( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // GLhandleARB glCreateShaderObjectARB( GLenum )
    maxParam = 1;
    READ_ENUM_PARAM(0);
    TR.skipResult();
    TR.skipLine();
    CHECK_USER_CALL(glCreateShaderObjectARB)
        UCT.glCreateShaderObjectARB(param[0].uv32bit);
    CHECK_GL_CALL(glCreateShaderObjectARB)
        JT.glCreateShaderObjectARB(param[0].uv32bit);
}

void STUB_glCullFace( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glCullFace( GLenum mode )
    maxParam = 1;
    READ_ENUM_PARAM(0);
    TR.skipLine();
    CHECK_USER_CALL(glCullFace)
        UCT.glCullFace(param[0].uv32bit);
    CHECK_GL_CALL(glCullFace)
        JT.glCullFace(param[0].uv32bit);
}

void STUB_glCullParameterdvEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glCullParameterdvEXT( GLenum, GLdouble * )
    maxParam = 2;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ARRAY_PARAM( 1, buffer0, TraceReader::TEXT_DOUBLE);
    TR.skipLine();
    CHECK_USER_CALL(glCullParameterdvEXT)
        UCT.glCullParameterdvEXT(param[0].uv32bit, (GLdouble *)param[1].ptr);
    CHECK_GL_CALL(glCullParameterdvEXT)
        JT.glCullParameterdvEXT(param[0].uv32bit, (GLdouble *)param[1].ptr);
}

void STUB_glCullParameterfvEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glCullParameterfvEXT( GLenum, GLfloat * )
    maxParam = 2;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ARRAY_PARAM( 1, buffer0, TraceReader::TEXT_FLOAT);
    TR.skipLine();
    CHECK_USER_CALL(glCullParameterfvEXT)
        UCT.glCullParameterfvEXT(param[0].uv32bit, (GLfloat *)param[1].ptr);
    CHECK_GL_CALL(glCullParameterfvEXT)
        JT.glCullParameterfvEXT(param[0].uv32bit, (GLfloat *)param[1].ptr);
}

void STUB_glCurrentPaletteMatrixARB( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glCurrentPaletteMatrixARB( GLint )
    maxParam = 1;
    READ_PARAM(v32bit,0);
    TR.skipLine();
    CHECK_USER_CALL(glCurrentPaletteMatrixARB)
        UCT.glCurrentPaletteMatrixARB(param[0].v32bit);
    CHECK_GL_CALL(glCurrentPaletteMatrixARB)
        JT.glCurrentPaletteMatrixARB(param[0].v32bit);
}

void STUB_glDeformSGIX( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glDeformSGIX( GLbitfield )
    maxParam = 1;
    READ_ORING_PARAM(0);
    TR.skipLine();
    CHECK_USER_CALL(glDeformSGIX)
        UCT.glDeformSGIX(param[0].uv32bit);
    CHECK_GL_CALL(glDeformSGIX)
        JT.glDeformSGIX(param[0].uv32bit);
}

void STUB_glDeformationMap3dSGIX( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glDeformationMap3dSGIX( GLenum, GLdouble, GLdouble, GLint, GLint, GLdouble, GLdouble, GLint, GLint, GLdouble, GLdouble, GLint, GLint, const GLdouble * )
    maxParam = 14;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_DOUBLE_PARAM(1);
    READ_DOUBLE_PARAM(2);
    READ_PARAM(v32bit,3);
    READ_PARAM(v32bit,4);
    READ_DOUBLE_PARAM(5);
    READ_DOUBLE_PARAM(6);
    READ_PARAM(v32bit,7);
    READ_PARAM(v32bit,8);
    READ_DOUBLE_PARAM(9);
    READ_DOUBLE_PARAM(10);
    READ_PARAM(v32bit,11);
    READ_PARAM(v32bit,12);
    READ_ARRAY_PARAM( 13, buffer0, TraceReader::TEXT_DOUBLE);
    TR.skipLine();
    CHECK_USER_CALL(glDeformationMap3dSGIX)
        UCT.glDeformationMap3dSGIX(param[0].uv32bit, param[1].fv64bit, param[2].fv64bit, param[3].v32bit, param[4].v32bit, param[5].fv64bit, param[6].fv64bit, param[7].v32bit, param[8].v32bit, param[9].fv64bit, param[10].fv64bit, param[11].v32bit, param[12].v32bit, (const GLdouble *)param[13].ptr);
    CHECK_GL_CALL(glDeformationMap3dSGIX)
        JT.glDeformationMap3dSGIX(param[0].uv32bit, param[1].fv64bit, param[2].fv64bit, param[3].v32bit, param[4].v32bit, param[5].fv64bit, param[6].fv64bit, param[7].v32bit, param[8].v32bit, param[9].fv64bit, param[10].fv64bit, param[11].v32bit, param[12].v32bit, (const GLdouble *)param[13].ptr);
}

void STUB_glDeformationMap3fSGIX( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glDeformationMap3fSGIX( GLenum, GLfloat, GLfloat, GLint, GLint, GLfloat, GLfloat, GLint, GLint, GLfloat, GLfloat, GLint, GLint, const GLfloat * )
    maxParam = 14;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_PARAM(fv32bit,1);
    READ_PARAM(fv32bit,2);
    READ_PARAM(v32bit,3);
    READ_PARAM(v32bit,4);
    READ_PARAM(fv32bit,5);
    READ_PARAM(fv32bit,6);
    READ_PARAM(v32bit,7);
    READ_PARAM(v32bit,8);
    READ_PARAM(fv32bit,9);
    READ_PARAM(fv32bit,10);
    READ_PARAM(v32bit,11);
    READ_PARAM(v32bit,12);
    READ_ARRAY_PARAM( 13, buffer0, TraceReader::TEXT_FLOAT);
    TR.skipLine();
    CHECK_USER_CALL(glDeformationMap3fSGIX)
        UCT.glDeformationMap3fSGIX(param[0].uv32bit, param[1].fv32bit, param[2].fv32bit, param[3].v32bit, param[4].v32bit, param[5].fv32bit, param[6].fv32bit, param[7].v32bit, param[8].v32bit, param[9].fv32bit, param[10].fv32bit, param[11].v32bit, param[12].v32bit, (const GLfloat *)param[13].ptr);
    CHECK_GL_CALL(glDeformationMap3fSGIX)
        JT.glDeformationMap3fSGIX(param[0].uv32bit, param[1].fv32bit, param[2].fv32bit, param[3].v32bit, param[4].v32bit, param[5].fv32bit, param[6].fv32bit, param[7].v32bit, param[8].v32bit, param[9].fv32bit, param[10].fv32bit, param[11].v32bit, param[12].v32bit, (const GLfloat *)param[13].ptr);
}

void STUB_glDeleteAsyncMarkersSGIX( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glDeleteAsyncMarkersSGIX( GLuint, GLsizei )
    maxParam = 2;
    READ_ENUM_PARAM(0);
    READ_PARAM(v32bit,1);
    TR.skipLine();
    CHECK_USER_CALL(glDeleteAsyncMarkersSGIX)
        UCT.glDeleteAsyncMarkersSGIX(param[0].uv32bit, param[1].v32bit);
    CHECK_GL_CALL(glDeleteAsyncMarkersSGIX)
        JT.glDeleteAsyncMarkersSGIX(param[0].uv32bit, param[1].v32bit);
}

void STUB_glDeleteBuffers( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glDeleteBuffers( GLsizei, const GLuint * )
    maxParam = 2;
    char buffer0[16*4096];
    READ_PARAM(v32bit,0);
    READ_ARRAY_PARAM( 1, buffer0, TraceReader::TEXT_INT);
    TR.skipLine();
    CHECK_USER_CALL(glDeleteBuffers)
        UCT.glDeleteBuffers(param[0].v32bit, (const GLuint *)param[1].ptr);
    CHECK_GL_CALL(glDeleteBuffers)
        JT.glDeleteBuffers(param[0].v32bit, (const GLuint *)param[1].ptr);
}

void STUB_glDeleteBuffersARB( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glDeleteBuffersARB( GLsizei, const GLuint * )
    maxParam = 2;
    char buffer0[16*4096];
    READ_PARAM(v32bit,0);
    READ_ARRAY_PARAM( 1, buffer0, TraceReader::TEXT_INT);
    TR.skipLine();
    CHECK_USER_CALL(glDeleteBuffersARB)
        UCT.glDeleteBuffersARB(param[0].v32bit, (const GLuint *)param[1].ptr);
    CHECK_GL_CALL(glDeleteBuffersARB)
        JT.glDeleteBuffersARB(param[0].v32bit, (const GLuint *)param[1].ptr);
}

void STUB_glDeleteFencesAPPLE( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glDeleteFencesAPPLE( GLsizei, const GLuint * )
    maxParam = 2;
    char buffer0[16*4096];
    READ_PARAM(v32bit,0);
    READ_ARRAY_PARAM( 1, buffer0, TraceReader::TEXT_INT);
    TR.skipLine();
    CHECK_USER_CALL(glDeleteFencesAPPLE)
        UCT.glDeleteFencesAPPLE(param[0].v32bit, (const GLuint *)param[1].ptr);
    CHECK_GL_CALL(glDeleteFencesAPPLE)
        JT.glDeleteFencesAPPLE(param[0].v32bit, (const GLuint *)param[1].ptr);
}

void STUB_glDeleteFencesNV( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glDeleteFencesNV( GLsizei, const GLuint * )
    maxParam = 2;
    char buffer0[16*4096];
    READ_PARAM(v32bit,0);
    READ_ARRAY_PARAM( 1, buffer0, TraceReader::TEXT_INT);
    TR.skipLine();
    CHECK_USER_CALL(glDeleteFencesNV)
        UCT.glDeleteFencesNV(param[0].v32bit, (const GLuint *)param[1].ptr);
    CHECK_GL_CALL(glDeleteFencesNV)
        JT.glDeleteFencesNV(param[0].v32bit, (const GLuint *)param[1].ptr);
}

void STUB_glDeleteFragmentShaderATI( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glDeleteFragmentShaderATI( GLuint )
    maxParam = 1;
    READ_ENUM_PARAM(0);
    TR.skipLine();
    CHECK_USER_CALL(glDeleteFragmentShaderATI)
        UCT.glDeleteFragmentShaderATI(param[0].uv32bit);
    CHECK_GL_CALL(glDeleteFragmentShaderATI)
        JT.glDeleteFragmentShaderATI(param[0].uv32bit);
}

void STUB_glDeleteFramebuffers( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glDeleteFramebuffers( GLsizei, const GLuint * )
    maxParam = 2;
    char buffer0[16*4096];
    READ_PARAM(v32bit,0);
    READ_ARRAY_PARAM( 1, buffer0, TraceReader::TEXT_INT);
    TR.skipLine();
    CHECK_USER_CALL(glDeleteFramebuffers)
        UCT.glDeleteFramebuffers(param[0].v32bit, (const GLuint *)param[1].ptr);
    CHECK_GL_CALL(glDeleteFramebuffers)
        JT.glDeleteFramebuffers(param[0].v32bit, (const GLuint *)param[1].ptr);
}

void STUB_glDeleteFramebuffersEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glDeleteFramebuffersEXT( GLsizei, const GLuint * )
    maxParam = 2;
    char buffer0[16*4096];
    READ_PARAM(v32bit,0);
    READ_ARRAY_PARAM( 1, buffer0, TraceReader::TEXT_INT);
    TR.skipLine();
    CHECK_USER_CALL(glDeleteFramebuffersEXT)
        UCT.glDeleteFramebuffersEXT(param[0].v32bit, (const GLuint *)param[1].ptr);
    CHECK_GL_CALL(glDeleteFramebuffersEXT)
        JT.glDeleteFramebuffersEXT(param[0].v32bit, (const GLuint *)param[1].ptr);
}

void STUB_glDeleteLists( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glDeleteLists( GLuint list, GLsizei range )
    maxParam = 2;
    READ_ENUM_PARAM(0);
    READ_PARAM(v32bit,1);
    TR.skipLine();
    CHECK_USER_CALL(glDeleteLists)
        UCT.glDeleteLists(param[0].uv32bit, param[1].v32bit);
    CHECK_GL_CALL(glDeleteLists)
        JT.glDeleteLists(param[0].uv32bit, param[1].v32bit);
}

void STUB_glDeleteObjectARB( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glDeleteObjectARB( GLhandleARB )
    maxParam = 1;
    READ_ENUM_PARAM(0);
    TR.skipLine();
    CHECK_USER_CALL(glDeleteObjectARB)
        UCT.glDeleteObjectARB(param[0].uv32bit);
    CHECK_GL_CALL(glDeleteObjectARB)
        JT.glDeleteObjectARB(param[0].uv32bit);
}

void STUB_glDeleteObjectBufferATI( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glDeleteObjectBufferATI( GLuint )
    maxParam = 1;
    READ_ENUM_PARAM(0);
    TR.skipLine();
    CHECK_USER_CALL(glDeleteObjectBufferATI)
        UCT.glDeleteObjectBufferATI(param[0].uv32bit);
    CHECK_GL_CALL(glDeleteObjectBufferATI)
        JT.glDeleteObjectBufferATI(param[0].uv32bit);
}

void STUB_glDeleteOcclusionQueriesNV( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glDeleteOcclusionQueriesNV( GLsizei, const GLuint * )
    maxParam = 2;
    char buffer0[16*4096];
    READ_PARAM(v32bit,0);
    READ_ARRAY_PARAM( 1, buffer0, TraceReader::TEXT_INT);
    TR.skipLine();
    CHECK_USER_CALL(glDeleteOcclusionQueriesNV)
        UCT.glDeleteOcclusionQueriesNV(param[0].v32bit, (const GLuint *)param[1].ptr);
    CHECK_GL_CALL(glDeleteOcclusionQueriesNV)
        JT.glDeleteOcclusionQueriesNV(param[0].v32bit, (const GLuint *)param[1].ptr);
}

void STUB_glDeletePerfMonitorsAMD( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glDeletePerfMonitorsAMD( GLsizei, GLuint * )
    maxParam = 2;
    char buffer0[16*4096];
    READ_PARAM(v32bit,0);
    READ_ARRAY_PARAM( 1, buffer0, TraceReader::TEXT_INT);
    TR.skipLine();
    CHECK_USER_CALL(glDeletePerfMonitorsAMD)
        UCT.glDeletePerfMonitorsAMD(param[0].v32bit, (GLuint *)param[1].ptr);
    CHECK_GL_CALL(glDeletePerfMonitorsAMD)
        JT.glDeletePerfMonitorsAMD(param[0].v32bit, (GLuint *)param[1].ptr);
}

void STUB_glDeleteProgram( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glDeleteProgram( GLuint )
    maxParam = 1;
    READ_ENUM_PARAM(0);
    TR.skipLine();
    CHECK_USER_CALL(glDeleteProgram)
        UCT.glDeleteProgram(param[0].uv32bit);
    CHECK_GL_CALL(glDeleteProgram)
        JT.glDeleteProgram(param[0].uv32bit);
}

void STUB_glDeleteProgramsARB( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glDeleteProgramsARB( GLsizei, const GLuint * )
    maxParam = 2;
    char buffer0[16*4096];
    READ_PARAM(v32bit,0);
    READ_ARRAY_PARAM( 1, buffer0, TraceReader::TEXT_INT);
    TR.skipLine();
    CHECK_USER_CALL(glDeleteProgramsARB)
        UCT.glDeleteProgramsARB(param[0].v32bit, (const GLuint *)param[1].ptr);
    CHECK_GL_CALL(glDeleteProgramsARB)
        JT.glDeleteProgramsARB(param[0].v32bit, (const GLuint *)param[1].ptr);
}

void STUB_glDeleteProgramsNV( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glDeleteProgramsNV( GLsizei, const GLuint * )
    maxParam = 2;
    char buffer0[16*4096];
    READ_PARAM(v32bit,0);
    READ_ARRAY_PARAM( 1, buffer0, TraceReader::TEXT_INT);
    TR.skipLine();
    CHECK_USER_CALL(glDeleteProgramsNV)
        UCT.glDeleteProgramsNV(param[0].v32bit, (const GLuint *)param[1].ptr);
    CHECK_GL_CALL(glDeleteProgramsNV)
        JT.glDeleteProgramsNV(param[0].v32bit, (const GLuint *)param[1].ptr);
}

void STUB_glDeleteQueries( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glDeleteQueries( GLsizei, const GLuint * )
    maxParam = 2;
    char buffer0[16*4096];
    READ_PARAM(v32bit,0);
    READ_ARRAY_PARAM( 1, buffer0, TraceReader::TEXT_INT);
    TR.skipLine();
    CHECK_USER_CALL(glDeleteQueries)
        UCT.glDeleteQueries(param[0].v32bit, (const GLuint *)param[1].ptr);
    CHECK_GL_CALL(glDeleteQueries)
        JT.glDeleteQueries(param[0].v32bit, (const GLuint *)param[1].ptr);
}

void STUB_glDeleteQueriesARB( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glDeleteQueriesARB( GLsizei, const GLuint * )
    maxParam = 2;
    char buffer0[16*4096];
    READ_PARAM(v32bit,0);
    READ_ARRAY_PARAM( 1, buffer0, TraceReader::TEXT_INT);
    TR.skipLine();
    CHECK_USER_CALL(glDeleteQueriesARB)
        UCT.glDeleteQueriesARB(param[0].v32bit, (const GLuint *)param[1].ptr);
    CHECK_GL_CALL(glDeleteQueriesARB)
        JT.glDeleteQueriesARB(param[0].v32bit, (const GLuint *)param[1].ptr);
}

void STUB_glDeleteRenderbuffers( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glDeleteRenderbuffers( GLsizei, const GLuint * )
    maxParam = 2;
    char buffer0[16*4096];
    READ_PARAM(v32bit,0);
    READ_ARRAY_PARAM( 1, buffer0, TraceReader::TEXT_INT);
    TR.skipLine();
    CHECK_USER_CALL(glDeleteRenderbuffers)
        UCT.glDeleteRenderbuffers(param[0].v32bit, (const GLuint *)param[1].ptr);
    CHECK_GL_CALL(glDeleteRenderbuffers)
        JT.glDeleteRenderbuffers(param[0].v32bit, (const GLuint *)param[1].ptr);
}

void STUB_glDeleteRenderbuffersEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glDeleteRenderbuffersEXT( GLsizei, const GLuint * )
    maxParam = 2;
    char buffer0[16*4096];
    READ_PARAM(v32bit,0);
    READ_ARRAY_PARAM( 1, buffer0, TraceReader::TEXT_INT);
    TR.skipLine();
    CHECK_USER_CALL(glDeleteRenderbuffersEXT)
        UCT.glDeleteRenderbuffersEXT(param[0].v32bit, (const GLuint *)param[1].ptr);
    CHECK_GL_CALL(glDeleteRenderbuffersEXT)
        JT.glDeleteRenderbuffersEXT(param[0].v32bit, (const GLuint *)param[1].ptr);
}

void STUB_glDeleteShader( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glDeleteShader( GLuint )
    maxParam = 1;
    READ_ENUM_PARAM(0);
    TR.skipLine();
    CHECK_USER_CALL(glDeleteShader)
        UCT.glDeleteShader(param[0].uv32bit);
    CHECK_GL_CALL(glDeleteShader)
        JT.glDeleteShader(param[0].uv32bit);
}

void STUB_glDeleteTextures( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glDeleteTextures( GLsizei n, const GLuint *textures )
    maxParam = 2;
    char buffer0[16*4096];
    READ_PARAM(v32bit,0);
    READ_ARRAY_PARAM( 1, buffer0, TraceReader::TEXT_INT);
    TR.skipLine();
    CHECK_USER_CALL(glDeleteTextures)
        UCT.glDeleteTextures(param[0].v32bit, (const GLuint *)param[1].ptr);
    CHECK_GL_CALL(glDeleteTextures)
        JT.glDeleteTextures(param[0].v32bit, (const GLuint *)param[1].ptr);
}

void STUB_glDeleteTexturesEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glDeleteTexturesEXT( GLsizei, const GLuint * )
    maxParam = 2;
    char buffer0[16*4096];
    READ_PARAM(v32bit,0);
    READ_ARRAY_PARAM( 1, buffer0, TraceReader::TEXT_INT);
    TR.skipLine();
    CHECK_USER_CALL(glDeleteTexturesEXT)
        UCT.glDeleteTexturesEXT(param[0].v32bit, (const GLuint *)param[1].ptr);
    CHECK_GL_CALL(glDeleteTexturesEXT)
        JT.glDeleteTexturesEXT(param[0].v32bit, (const GLuint *)param[1].ptr);
}

void STUB_glDeleteTransformFeedbacksNV( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glDeleteTransformFeedbacksNV( GLsizei, const GLuint * )
    maxParam = 2;
    char buffer0[16*4096];
    READ_PARAM(v32bit,0);
    READ_ARRAY_PARAM( 1, buffer0, TraceReader::TEXT_INT);
    TR.skipLine();
    CHECK_USER_CALL(glDeleteTransformFeedbacksNV)
        UCT.glDeleteTransformFeedbacksNV(param[0].v32bit, (const GLuint *)param[1].ptr);
    CHECK_GL_CALL(glDeleteTransformFeedbacksNV)
        JT.glDeleteTransformFeedbacksNV(param[0].v32bit, (const GLuint *)param[1].ptr);
}

void STUB_glDeleteVertexArrays( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glDeleteVertexArrays( GLsizei, const GLuint * )
    maxParam = 2;
    char buffer0[16*4096];
    READ_PARAM(v32bit,0);
    READ_ARRAY_PARAM( 1, buffer0, TraceReader::TEXT_INT);
    TR.skipLine();
    CHECK_USER_CALL(glDeleteVertexArrays)
        UCT.glDeleteVertexArrays(param[0].v32bit, (const GLuint *)param[1].ptr);
    CHECK_GL_CALL(glDeleteVertexArrays)
        JT.glDeleteVertexArrays(param[0].v32bit, (const GLuint *)param[1].ptr);
}

void STUB_glDeleteVertexArraysAPPLE( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glDeleteVertexArraysAPPLE( GLsizei, const GLuint * )
    maxParam = 2;
    char buffer0[16*4096];
    READ_PARAM(v32bit,0);
    READ_ARRAY_PARAM( 1, buffer0, TraceReader::TEXT_INT);
    TR.skipLine();
    CHECK_USER_CALL(glDeleteVertexArraysAPPLE)
        UCT.glDeleteVertexArraysAPPLE(param[0].v32bit, (const GLuint *)param[1].ptr);
    CHECK_GL_CALL(glDeleteVertexArraysAPPLE)
        JT.glDeleteVertexArraysAPPLE(param[0].v32bit, (const GLuint *)param[1].ptr);
}

void STUB_glDeleteVertexShaderEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glDeleteVertexShaderEXT( GLuint )
    maxParam = 1;
    READ_ENUM_PARAM(0);
    TR.skipLine();
    CHECK_USER_CALL(glDeleteVertexShaderEXT)
        UCT.glDeleteVertexShaderEXT(param[0].uv32bit);
    CHECK_GL_CALL(glDeleteVertexShaderEXT)
        JT.glDeleteVertexShaderEXT(param[0].uv32bit);
}

void STUB_glDepthBoundsEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glDepthBoundsEXT( GLclampd, GLclampd )
    maxParam = 2;
    READ_DOUBLE_PARAM(0);
    READ_DOUBLE_PARAM(1);
    TR.skipLine();
    CHECK_USER_CALL(glDepthBoundsEXT)
        UCT.glDepthBoundsEXT(param[0].fv64bit, param[1].fv64bit);
    CHECK_GL_CALL(glDepthBoundsEXT)
        JT.glDepthBoundsEXT(param[0].fv64bit, param[1].fv64bit);
}

void STUB_glDepthBoundsdNV( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glDepthBoundsdNV( GLdouble, GLdouble )
    maxParam = 2;
    READ_DOUBLE_PARAM(0);
    READ_DOUBLE_PARAM(1);
    TR.skipLine();
    CHECK_USER_CALL(glDepthBoundsdNV)
        UCT.glDepthBoundsdNV(param[0].fv64bit, param[1].fv64bit);
    CHECK_GL_CALL(glDepthBoundsdNV)
        JT.glDepthBoundsdNV(param[0].fv64bit, param[1].fv64bit);
}

void STUB_glDepthFunc( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glDepthFunc( GLenum func )
    maxParam = 1;
    READ_ENUM_PARAM(0);
    TR.skipLine();
    CHECK_USER_CALL(glDepthFunc)
        UCT.glDepthFunc(param[0].uv32bit);
    CHECK_GL_CALL(glDepthFunc)
        JT.glDepthFunc(param[0].uv32bit);
}

void STUB_glDepthMask( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glDepthMask( GLboolean flag )
    maxParam = 1;
    READ_BOOLEAN_PARAM(0);
    TR.skipLine();
    CHECK_USER_CALL(glDepthMask)
        UCT.glDepthMask(param[0].boolean);
    CHECK_GL_CALL(glDepthMask)
        JT.glDepthMask(param[0].boolean);
}

void STUB_glDepthRange( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glDepthRange( GLclampd near_val, GLclampd far_val )
    maxParam = 2;
    READ_DOUBLE_PARAM(0);
    READ_DOUBLE_PARAM(1);
    TR.skipLine();
    CHECK_USER_CALL(glDepthRange)
        UCT.glDepthRange(param[0].fv64bit, param[1].fv64bit);
    CHECK_GL_CALL(glDepthRange)
        JT.glDepthRange(param[0].fv64bit, param[1].fv64bit);
}

void STUB_glDepthRangedNV( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glDepthRangedNV( GLdouble, GLdouble )
    maxParam = 2;
    READ_DOUBLE_PARAM(0);
    READ_DOUBLE_PARAM(1);
    TR.skipLine();
    CHECK_USER_CALL(glDepthRangedNV)
        UCT.glDepthRangedNV(param[0].fv64bit, param[1].fv64bit);
    CHECK_GL_CALL(glDepthRangedNV)
        JT.glDepthRangedNV(param[0].fv64bit, param[1].fv64bit);
}

void STUB_glDetachObjectARB( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glDetachObjectARB( GLhandleARB, GLhandleARB )
    maxParam = 2;
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    TR.skipLine();
    CHECK_USER_CALL(glDetachObjectARB)
        UCT.glDetachObjectARB(param[0].uv32bit, param[1].uv32bit);
    CHECK_GL_CALL(glDetachObjectARB)
        JT.glDetachObjectARB(param[0].uv32bit, param[1].uv32bit);
}

void STUB_glDetachShader( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glDetachShader( GLuint, GLuint )
    maxParam = 2;
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    TR.skipLine();
    CHECK_USER_CALL(glDetachShader)
        UCT.glDetachShader(param[0].uv32bit, param[1].uv32bit);
    CHECK_GL_CALL(glDetachShader)
        JT.glDetachShader(param[0].uv32bit, param[1].uv32bit);
}

void STUB_glDetailTexFuncSGIS( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glDetailTexFuncSGIS( GLenum, GLsizei, const GLfloat * )
    maxParam = 3;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_PARAM(v32bit,1);
    READ_ARRAY_PARAM( 2, buffer0, TraceReader::TEXT_FLOAT);
    TR.skipLine();
    CHECK_USER_CALL(glDetailTexFuncSGIS)
        UCT.glDetailTexFuncSGIS(param[0].uv32bit, param[1].v32bit, (const GLfloat *)param[2].ptr);
    CHECK_GL_CALL(glDetailTexFuncSGIS)
        JT.glDetailTexFuncSGIS(param[0].uv32bit, param[1].v32bit, (const GLfloat *)param[2].ptr);
}

void STUB_glDisable( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glDisable( GLenum cap )
    maxParam = 1;
    READ_ENUM_PARAM(0);
    TR.skipLine();
    CHECK_USER_CALL(glDisable)
        UCT.glDisable(param[0].uv32bit);
    CHECK_GL_CALL(glDisable)
        JT.glDisable(param[0].uv32bit);
}

void STUB_glDisableClientState( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glDisableClientState( GLenum cap )
    maxParam = 1;
    READ_ENUM_PARAM(0);
    TR.skipLine();
    CHECK_USER_CALL(glDisableClientState)
        UCT.glDisableClientState(param[0].uv32bit);
    CHECK_GL_CALL(glDisableClientState)
        JT.glDisableClientState(param[0].uv32bit);
}

void STUB_glDisableClientStateIndexedEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glDisableClientStateIndexedEXT( GLenum, GLuint )
    maxParam = 2;
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    TR.skipLine();
    CHECK_USER_CALL(glDisableClientStateIndexedEXT)
        UCT.glDisableClientStateIndexedEXT(param[0].uv32bit, param[1].uv32bit);
    CHECK_GL_CALL(glDisableClientStateIndexedEXT)
        JT.glDisableClientStateIndexedEXT(param[0].uv32bit, param[1].uv32bit);
}

void STUB_glDisableIndexedEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glDisableIndexedEXT( GLenum, GLuint )
    maxParam = 2;
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    TR.skipLine();
    CHECK_USER_CALL(glDisableIndexedEXT)
        UCT.glDisableIndexedEXT(param[0].uv32bit, param[1].uv32bit);
    CHECK_GL_CALL(glDisableIndexedEXT)
        JT.glDisableIndexedEXT(param[0].uv32bit, param[1].uv32bit);
}

void STUB_glDisableVariantClientStateEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glDisableVariantClientStateEXT( GLuint )
    maxParam = 1;
    READ_ENUM_PARAM(0);
    TR.skipLine();
    CHECK_USER_CALL(glDisableVariantClientStateEXT)
        UCT.glDisableVariantClientStateEXT(param[0].uv32bit);
    CHECK_GL_CALL(glDisableVariantClientStateEXT)
        JT.glDisableVariantClientStateEXT(param[0].uv32bit);
}

void STUB_glDisableVertexAttribArray( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glDisableVertexAttribArray( GLuint )
    maxParam = 1;
    READ_ENUM_PARAM(0);
    TR.skipLine();
    CHECK_USER_CALL(glDisableVertexAttribArray)
        UCT.glDisableVertexAttribArray(param[0].uv32bit);
    CHECK_GL_CALL(glDisableVertexAttribArray)
        JT.glDisableVertexAttribArray(param[0].uv32bit);
}

void STUB_glDisableVertexAttribArrayARB( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glDisableVertexAttribArrayARB( GLuint )
    maxParam = 1;
    READ_ENUM_PARAM(0);
    TR.skipLine();
    CHECK_USER_CALL(glDisableVertexAttribArrayARB)
        UCT.glDisableVertexAttribArrayARB(param[0].uv32bit);
    CHECK_GL_CALL(glDisableVertexAttribArrayARB)
        JT.glDisableVertexAttribArrayARB(param[0].uv32bit);
}

void STUB_glDisablei( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glDisablei( GLenum, GLuint )
    maxParam = 2;
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    TR.skipLine();
    CHECK_USER_CALL(glDisablei)
        UCT.glDisablei(param[0].uv32bit, param[1].uv32bit);
    CHECK_GL_CALL(glDisablei)
        JT.glDisablei(param[0].uv32bit, param[1].uv32bit);
}

void STUB_glDrawArrays( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glDrawArrays( GLenum mode, GLint first, GLsizei count )
    maxParam = 3;
    READ_ENUM_PARAM(0);
    READ_PARAM(v32bit,1);
    READ_PARAM(v32bit,2);
    TR.skipLine();
    CHECK_USER_CALL(glDrawArrays)
        UCT.glDrawArrays(param[0].uv32bit, param[1].v32bit, param[2].v32bit);
    CHECK_GL_CALL(glDrawArrays)
        JT.glDrawArrays(param[0].uv32bit, param[1].v32bit, param[2].v32bit);
}

void STUB_glDrawArraysEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glDrawArraysEXT( GLenum, GLint, GLsizei )
    maxParam = 3;
    READ_ENUM_PARAM(0);
    READ_PARAM(v32bit,1);
    READ_PARAM(v32bit,2);
    TR.skipLine();
    CHECK_USER_CALL(glDrawArraysEXT)
        UCT.glDrawArraysEXT(param[0].uv32bit, param[1].v32bit, param[2].v32bit);
    CHECK_GL_CALL(glDrawArraysEXT)
        JT.glDrawArraysEXT(param[0].uv32bit, param[1].v32bit, param[2].v32bit);
}

void STUB_glDrawArraysInstanced( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glDrawArraysInstanced( GLenum, GLint, GLsizei, GLsizei )
    maxParam = 4;
    READ_ENUM_PARAM(0);
    READ_PARAM(v32bit,1);
    READ_PARAM(v32bit,2);
    READ_PARAM(v32bit,3);
    TR.skipLine();
    CHECK_USER_CALL(glDrawArraysInstanced)
        UCT.glDrawArraysInstanced(param[0].uv32bit, param[1].v32bit, param[2].v32bit, param[3].v32bit);
    CHECK_GL_CALL(glDrawArraysInstanced)
        JT.glDrawArraysInstanced(param[0].uv32bit, param[1].v32bit, param[2].v32bit, param[3].v32bit);
}

void STUB_glDrawArraysInstancedARB( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glDrawArraysInstancedARB( GLenum, GLint, GLsizei, GLsizei )
    maxParam = 4;
    READ_ENUM_PARAM(0);
    READ_PARAM(v32bit,1);
    READ_PARAM(v32bit,2);
    READ_PARAM(v32bit,3);
    TR.skipLine();
    CHECK_USER_CALL(glDrawArraysInstancedARB)
        UCT.glDrawArraysInstancedARB(param[0].uv32bit, param[1].v32bit, param[2].v32bit, param[3].v32bit);
    CHECK_GL_CALL(glDrawArraysInstancedARB)
        JT.glDrawArraysInstancedARB(param[0].uv32bit, param[1].v32bit, param[2].v32bit, param[3].v32bit);
}

void STUB_glDrawArraysInstancedEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glDrawArraysInstancedEXT( GLenum, GLint, GLsizei, GLsizei )
    maxParam = 4;
    READ_ENUM_PARAM(0);
    READ_PARAM(v32bit,1);
    READ_PARAM(v32bit,2);
    READ_PARAM(v32bit,3);
    TR.skipLine();
    CHECK_USER_CALL(glDrawArraysInstancedEXT)
        UCT.glDrawArraysInstancedEXT(param[0].uv32bit, param[1].v32bit, param[2].v32bit, param[3].v32bit);
    CHECK_GL_CALL(glDrawArraysInstancedEXT)
        JT.glDrawArraysInstancedEXT(param[0].uv32bit, param[1].v32bit, param[2].v32bit, param[3].v32bit);
}

void STUB_glDrawBuffer( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glDrawBuffer( GLenum mode )
    maxParam = 1;
    READ_ENUM_PARAM(0);
    TR.skipLine();
    CHECK_USER_CALL(glDrawBuffer)
        UCT.glDrawBuffer(param[0].uv32bit);
    CHECK_GL_CALL(glDrawBuffer)
        JT.glDrawBuffer(param[0].uv32bit);
}

void STUB_glDrawBuffers( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glDrawBuffers( GLsizei, const GLenum * )
    maxParam = 2;
    char buffer0[16*4096];
    READ_PARAM(v32bit,0);
    READ_ARRAY_PARAM( 1, buffer0, TraceReader::TEXT_INT);
    TR.skipLine();
    CHECK_USER_CALL(glDrawBuffers)
        UCT.glDrawBuffers(param[0].v32bit, (const GLenum *)param[1].ptr);
    CHECK_GL_CALL(glDrawBuffers)
        JT.glDrawBuffers(param[0].v32bit, (const GLenum *)param[1].ptr);
}

void STUB_glDrawBuffersARB( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glDrawBuffersARB( GLsizei, const GLenum * )
    maxParam = 2;
    char buffer0[16*4096];
    READ_PARAM(v32bit,0);
    READ_ARRAY_PARAM( 1, buffer0, TraceReader::TEXT_INT);
    TR.skipLine();
    CHECK_USER_CALL(glDrawBuffersARB)
        UCT.glDrawBuffersARB(param[0].v32bit, (const GLenum *)param[1].ptr);
    CHECK_GL_CALL(glDrawBuffersARB)
        JT.glDrawBuffersARB(param[0].v32bit, (const GLenum *)param[1].ptr);
}

void STUB_glDrawBuffersATI( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glDrawBuffersATI( GLsizei, const GLenum * )
    maxParam = 2;
    char buffer0[16*4096];
    READ_PARAM(v32bit,0);
    READ_ARRAY_PARAM( 1, buffer0, TraceReader::TEXT_INT);
    TR.skipLine();
    CHECK_USER_CALL(glDrawBuffersATI)
        UCT.glDrawBuffersATI(param[0].v32bit, (const GLenum *)param[1].ptr);
    CHECK_GL_CALL(glDrawBuffersATI)
        JT.glDrawBuffersATI(param[0].v32bit, (const GLenum *)param[1].ptr);
}

void STUB_glDrawElementArrayAPPLE( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glDrawElementArrayAPPLE( GLenum, GLint, GLsizei )
    maxParam = 3;
    READ_ENUM_PARAM(0);
    READ_PARAM(v32bit,1);
    READ_PARAM(v32bit,2);
    TR.skipLine();
    CHECK_USER_CALL(glDrawElementArrayAPPLE)
        UCT.glDrawElementArrayAPPLE(param[0].uv32bit, param[1].v32bit, param[2].v32bit);
    CHECK_GL_CALL(glDrawElementArrayAPPLE)
        JT.glDrawElementArrayAPPLE(param[0].uv32bit, param[1].v32bit, param[2].v32bit);
}

void STUB_glDrawElementArrayATI( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glDrawElementArrayATI( GLenum, GLsizei )
    maxParam = 2;
    READ_ENUM_PARAM(0);
    READ_PARAM(v32bit,1);
    TR.skipLine();
    CHECK_USER_CALL(glDrawElementArrayATI)
        UCT.glDrawElementArrayATI(param[0].uv32bit, param[1].v32bit);
    CHECK_GL_CALL(glDrawElementArrayATI)
        JT.glDrawElementArrayATI(param[0].uv32bit, param[1].v32bit);
}

void STUB_glDrawElements( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glDrawElements( GLenum mode, GLsizei count, GLenum type, const GLvoid *indices )
    maxParam = 4;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_PARAM(v32bit,1);
    READ_ENUM_PARAM(2);
    READ_ARRAY_PARAM( 3, buffer0, TraceReader::TEXT_IGNORE);
    TR.skipLine();
    CHECK_USER_CALL(glDrawElements)
        UCT.glDrawElements(param[0].uv32bit, param[1].v32bit, param[2].uv32bit, (const GLvoid *)param[3].ptr);
    CHECK_GL_CALL(glDrawElements)
        JT.glDrawElements(param[0].uv32bit, param[1].v32bit, param[2].uv32bit, (const GLvoid *)param[3].ptr);
}

void STUB_glDrawElementsInstanced( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glDrawElementsInstanced( GLenum, GLsizei, GLenum, const GLvoid *, GLsizei )
    maxParam = 5;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_PARAM(v32bit,1);
    READ_ENUM_PARAM(2);
    READ_ARRAY_PARAM( 3, buffer0, TraceReader::TEXT_IGNORE);
    READ_PARAM(v32bit,4);
    TR.skipLine();
    CHECK_USER_CALL(glDrawElementsInstanced)
        UCT.glDrawElementsInstanced(param[0].uv32bit, param[1].v32bit, param[2].uv32bit, (const GLvoid *)param[3].ptr, param[4].v32bit);
    CHECK_GL_CALL(glDrawElementsInstanced)
        JT.glDrawElementsInstanced(param[0].uv32bit, param[1].v32bit, param[2].uv32bit, (const GLvoid *)param[3].ptr, param[4].v32bit);
}

void STUB_glDrawElementsInstancedARB( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glDrawElementsInstancedARB( GLenum, GLsizei, GLenum, const GLvoid *, GLsizei )
    maxParam = 5;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_PARAM(v32bit,1);
    READ_ENUM_PARAM(2);
    READ_ARRAY_PARAM( 3, buffer0, TraceReader::TEXT_IGNORE);
    READ_PARAM(v32bit,4);
    TR.skipLine();
    CHECK_USER_CALL(glDrawElementsInstancedARB)
        UCT.glDrawElementsInstancedARB(param[0].uv32bit, param[1].v32bit, param[2].uv32bit, (const GLvoid *)param[3].ptr, param[4].v32bit);
    CHECK_GL_CALL(glDrawElementsInstancedARB)
        JT.glDrawElementsInstancedARB(param[0].uv32bit, param[1].v32bit, param[2].uv32bit, (const GLvoid *)param[3].ptr, param[4].v32bit);
}

void STUB_glDrawElementsInstancedEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glDrawElementsInstancedEXT( GLenum, GLsizei, GLenum, const GLvoid *, GLsizei )
    maxParam = 5;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_PARAM(v32bit,1);
    READ_ENUM_PARAM(2);
    READ_ARRAY_PARAM( 3, buffer0, TraceReader::TEXT_IGNORE);
    READ_PARAM(v32bit,4);
    TR.skipLine();
    CHECK_USER_CALL(glDrawElementsInstancedEXT)
        UCT.glDrawElementsInstancedEXT(param[0].uv32bit, param[1].v32bit, param[2].uv32bit, (const GLvoid *)param[3].ptr, param[4].v32bit);
    CHECK_GL_CALL(glDrawElementsInstancedEXT)
        JT.glDrawElementsInstancedEXT(param[0].uv32bit, param[1].v32bit, param[2].uv32bit, (const GLvoid *)param[3].ptr, param[4].v32bit);
}

void STUB_glDrawPixels( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glDrawPixels( GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *pixels )
    maxParam = 5;
    char buffer0[16*4096];
    READ_PARAM(v32bit,0);
    READ_PARAM(v32bit,1);
    READ_ENUM_PARAM(2);
    READ_ENUM_PARAM(3);
    READ_ARRAY_PARAM( 4, buffer0, TraceReader::TEXT_IGNORE);
    TR.skipLine();
    CHECK_USER_CALL(glDrawPixels)
        UCT.glDrawPixels(param[0].v32bit, param[1].v32bit, param[2].uv32bit, param[3].uv32bit, (const GLvoid *)param[4].ptr);
    CHECK_GL_CALL(glDrawPixels)
        JT.glDrawPixels(param[0].v32bit, param[1].v32bit, param[2].uv32bit, param[3].uv32bit, (const GLvoid *)param[4].ptr);
}

void STUB_glDrawRangeElementArrayAPPLE( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glDrawRangeElementArrayAPPLE( GLenum, GLuint, GLuint, GLint, GLsizei )
    maxParam = 5;
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_ENUM_PARAM(2);
    READ_PARAM(v32bit,3);
    READ_PARAM(v32bit,4);
    TR.skipLine();
    CHECK_USER_CALL(glDrawRangeElementArrayAPPLE)
        UCT.glDrawRangeElementArrayAPPLE(param[0].uv32bit, param[1].uv32bit, param[2].uv32bit, param[3].v32bit, param[4].v32bit);
    CHECK_GL_CALL(glDrawRangeElementArrayAPPLE)
        JT.glDrawRangeElementArrayAPPLE(param[0].uv32bit, param[1].uv32bit, param[2].uv32bit, param[3].v32bit, param[4].v32bit);
}

void STUB_glDrawRangeElementArrayATI( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glDrawRangeElementArrayATI( GLenum, GLuint, GLuint, GLsizei )
    maxParam = 4;
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_ENUM_PARAM(2);
    READ_PARAM(v32bit,3);
    TR.skipLine();
    CHECK_USER_CALL(glDrawRangeElementArrayATI)
        UCT.glDrawRangeElementArrayATI(param[0].uv32bit, param[1].uv32bit, param[2].uv32bit, param[3].v32bit);
    CHECK_GL_CALL(glDrawRangeElementArrayATI)
        JT.glDrawRangeElementArrayATI(param[0].uv32bit, param[1].uv32bit, param[2].uv32bit, param[3].v32bit);
}

void STUB_glDrawRangeElements( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glDrawRangeElements( GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const GLvoid *indices )
    maxParam = 6;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_ENUM_PARAM(2);
    READ_PARAM(v32bit,3);
    READ_ENUM_PARAM(4);
    READ_ARRAY_PARAM( 5, buffer0, TraceReader::TEXT_IGNORE);
    TR.skipLine();
    CHECK_USER_CALL(glDrawRangeElements)
        UCT.glDrawRangeElements(param[0].uv32bit, param[1].uv32bit, param[2].uv32bit, param[3].v32bit, param[4].uv32bit, (const GLvoid *)param[5].ptr);
    CHECK_GL_CALL(glDrawRangeElements)
        JT.glDrawRangeElements(param[0].uv32bit, param[1].uv32bit, param[2].uv32bit, param[3].v32bit, param[4].uv32bit, (const GLvoid *)param[5].ptr);
}

void STUB_glDrawRangeElementsEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glDrawRangeElementsEXT( GLenum, GLuint, GLuint, GLsizei, GLenum, const GLvoid * )
    maxParam = 6;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_ENUM_PARAM(2);
    READ_PARAM(v32bit,3);
    READ_ENUM_PARAM(4);
    READ_ARRAY_PARAM( 5, buffer0, TraceReader::TEXT_IGNORE);
    TR.skipLine();
    CHECK_USER_CALL(glDrawRangeElementsEXT)
        UCT.glDrawRangeElementsEXT(param[0].uv32bit, param[1].uv32bit, param[2].uv32bit, param[3].v32bit, param[4].uv32bit, (const GLvoid *)param[5].ptr);
    CHECK_GL_CALL(glDrawRangeElementsEXT)
        JT.glDrawRangeElementsEXT(param[0].uv32bit, param[1].uv32bit, param[2].uv32bit, param[3].v32bit, param[4].uv32bit, (const GLvoid *)param[5].ptr);
}

void STUB_glDrawTransformFeedbackNV( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glDrawTransformFeedbackNV( GLenum, GLuint )
    maxParam = 2;
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    TR.skipLine();
    CHECK_USER_CALL(glDrawTransformFeedbackNV)
        UCT.glDrawTransformFeedbackNV(param[0].uv32bit, param[1].uv32bit);
    CHECK_GL_CALL(glDrawTransformFeedbackNV)
        JT.glDrawTransformFeedbackNV(param[0].uv32bit, param[1].uv32bit);
}

void STUB_glEdgeFlag( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glEdgeFlag( GLboolean flag )
    maxParam = 1;
    READ_BOOLEAN_PARAM(0);
    TR.skipLine();
    CHECK_USER_CALL(glEdgeFlag)
        UCT.glEdgeFlag(param[0].boolean);
    CHECK_GL_CALL(glEdgeFlag)
        JT.glEdgeFlag(param[0].boolean);
}

void STUB_glEdgeFlagPointer( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glEdgeFlagPointer( GLsizei stride, const GLvoid *ptr )
    maxParam = 2;
    char buffer0[16*4096];
    READ_PARAM(v32bit,0);
    READ_ARRAY_PARAM( 1, buffer0, TraceReader::TEXT_IGNORE);
    TR.skipLine();
    CHECK_USER_CALL(glEdgeFlagPointer)
        UCT.glEdgeFlagPointer(param[0].v32bit, (const GLvoid *)param[1].ptr);
    CHECK_GL_CALL(glEdgeFlagPointer)
        JT.glEdgeFlagPointer(param[0].v32bit, (const GLvoid *)param[1].ptr);
}

void STUB_glEdgeFlagPointerEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glEdgeFlagPointerEXT( GLsizei, GLsizei, const GLboolean * )
    maxParam = 3;
    char buffer0[16*4096];
    READ_PARAM(v32bit,0);
    READ_PARAM(v32bit,1);
    READ_ARRAY_PARAM( 2, buffer0, TraceReader::TEXT_BYTE);
    TR.skipLine();
    CHECK_USER_CALL(glEdgeFlagPointerEXT)
        UCT.glEdgeFlagPointerEXT(param[0].v32bit, param[1].v32bit, (const GLboolean *)param[2].ptr);
    CHECK_GL_CALL(glEdgeFlagPointerEXT)
        JT.glEdgeFlagPointerEXT(param[0].v32bit, param[1].v32bit, (const GLboolean *)param[2].ptr);
}

void STUB_glEdgeFlagv( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glEdgeFlagv( const GLboolean *flag )
    maxParam = 1;
    char buffer0[16*4096];
    READ_ARRAY_PARAM( 0, buffer0, TraceReader::TEXT_BYTE);
    TR.skipLine();
    CHECK_USER_CALL(glEdgeFlagv)
        UCT.glEdgeFlagv((const GLboolean *)param[0].ptr);
    CHECK_GL_CALL(glEdgeFlagv)
        JT.glEdgeFlagv((const GLboolean *)param[0].ptr);
}

void STUB_glElementPointerAPPLE( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glElementPointerAPPLE( GLenum, const GLvoid * )
    maxParam = 2;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ARRAY_PARAM( 1, buffer0, TraceReader::TEXT_IGNORE);
    TR.skipLine();
    CHECK_USER_CALL(glElementPointerAPPLE)
        UCT.glElementPointerAPPLE(param[0].uv32bit, (const GLvoid *)param[1].ptr);
    CHECK_GL_CALL(glElementPointerAPPLE)
        JT.glElementPointerAPPLE(param[0].uv32bit, (const GLvoid *)param[1].ptr);
}

void STUB_glElementPointerATI( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glElementPointerATI( GLenum, const GLvoid * )
    maxParam = 2;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ARRAY_PARAM( 1, buffer0, TraceReader::TEXT_IGNORE);
    TR.skipLine();
    CHECK_USER_CALL(glElementPointerATI)
        UCT.glElementPointerATI(param[0].uv32bit, (const GLvoid *)param[1].ptr);
    CHECK_GL_CALL(glElementPointerATI)
        JT.glElementPointerATI(param[0].uv32bit, (const GLvoid *)param[1].ptr);
}

void STUB_glEnable( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glEnable( GLenum cap )
    maxParam = 1;
    READ_ENUM_PARAM(0);
    TR.skipLine();
    CHECK_USER_CALL(glEnable)
        UCT.glEnable(param[0].uv32bit);
    CHECK_GL_CALL(glEnable)
        JT.glEnable(param[0].uv32bit);
}

void STUB_glEnableClientState( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glEnableClientState( GLenum cap )
    maxParam = 1;
    READ_ENUM_PARAM(0);
    TR.skipLine();
    CHECK_USER_CALL(glEnableClientState)
        UCT.glEnableClientState(param[0].uv32bit);
    CHECK_GL_CALL(glEnableClientState)
        JT.glEnableClientState(param[0].uv32bit);
}

void STUB_glEnableClientStateIndexedEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glEnableClientStateIndexedEXT( GLenum, GLuint )
    maxParam = 2;
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    TR.skipLine();
    CHECK_USER_CALL(glEnableClientStateIndexedEXT)
        UCT.glEnableClientStateIndexedEXT(param[0].uv32bit, param[1].uv32bit);
    CHECK_GL_CALL(glEnableClientStateIndexedEXT)
        JT.glEnableClientStateIndexedEXT(param[0].uv32bit, param[1].uv32bit);
}

void STUB_glEnableIndexedEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glEnableIndexedEXT( GLenum, GLuint )
    maxParam = 2;
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    TR.skipLine();
    CHECK_USER_CALL(glEnableIndexedEXT)
        UCT.glEnableIndexedEXT(param[0].uv32bit, param[1].uv32bit);
    CHECK_GL_CALL(glEnableIndexedEXT)
        JT.glEnableIndexedEXT(param[0].uv32bit, param[1].uv32bit);
}

void STUB_glEnableVariantClientStateEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glEnableVariantClientStateEXT( GLuint )
    maxParam = 1;
    READ_ENUM_PARAM(0);
    TR.skipLine();
    CHECK_USER_CALL(glEnableVariantClientStateEXT)
        UCT.glEnableVariantClientStateEXT(param[0].uv32bit);
    CHECK_GL_CALL(glEnableVariantClientStateEXT)
        JT.glEnableVariantClientStateEXT(param[0].uv32bit);
}

void STUB_glEnableVertexAttribArray( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glEnableVertexAttribArray( GLuint )
    maxParam = 1;
    READ_ENUM_PARAM(0);
    TR.skipLine();
    CHECK_USER_CALL(glEnableVertexAttribArray)
        UCT.glEnableVertexAttribArray(param[0].uv32bit);
    CHECK_GL_CALL(glEnableVertexAttribArray)
        JT.glEnableVertexAttribArray(param[0].uv32bit);
}

void STUB_glEnableVertexAttribArrayARB( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glEnableVertexAttribArrayARB( GLuint )
    maxParam = 1;
    READ_ENUM_PARAM(0);
    TR.skipLine();
    CHECK_USER_CALL(glEnableVertexAttribArrayARB)
        UCT.glEnableVertexAttribArrayARB(param[0].uv32bit);
    CHECK_GL_CALL(glEnableVertexAttribArrayARB)
        JT.glEnableVertexAttribArrayARB(param[0].uv32bit);
}

void STUB_glEnablei( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glEnablei( GLenum, GLuint )
    maxParam = 2;
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    TR.skipLine();
    CHECK_USER_CALL(glEnablei)
        UCT.glEnablei(param[0].uv32bit, param[1].uv32bit);
    CHECK_GL_CALL(glEnablei)
        JT.glEnablei(param[0].uv32bit, param[1].uv32bit);
}

void STUB_glEnd( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glEnd(  )
    maxParam = 0;
    TR.skipLine();
    CHECK_USER_CALL(glEnd)
        UCT.glEnd();
    CHECK_GL_CALL(glEnd)
        JT.glEnd();
}

void STUB_glEndConditionalRender( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glEndConditionalRender(  )
    maxParam = 0;
    TR.skipLine();
    CHECK_USER_CALL(glEndConditionalRender)
        UCT.glEndConditionalRender();
    CHECK_GL_CALL(glEndConditionalRender)
        JT.glEndConditionalRender();
}

void STUB_glEndConditionalRenderNV( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glEndConditionalRenderNV(  )
    maxParam = 0;
    TR.skipLine();
    CHECK_USER_CALL(glEndConditionalRenderNV)
        UCT.glEndConditionalRenderNV();
    CHECK_GL_CALL(glEndConditionalRenderNV)
        JT.glEndConditionalRenderNV();
}

void STUB_glEndFragmentShaderATI( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glEndFragmentShaderATI(  )
    maxParam = 0;
    TR.skipLine();
    CHECK_USER_CALL(glEndFragmentShaderATI)
        UCT.glEndFragmentShaderATI();
    CHECK_GL_CALL(glEndFragmentShaderATI)
        JT.glEndFragmentShaderATI();
}

void STUB_glEndList( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glEndList(  )
    maxParam = 0;
    TR.skipLine();
    CHECK_USER_CALL(glEndList)
        UCT.glEndList();
    CHECK_GL_CALL(glEndList)
        JT.glEndList();
}

void STUB_glEndOcclusionQueryNV( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glEndOcclusionQueryNV(  )
    maxParam = 0;
    TR.skipLine();
    CHECK_USER_CALL(glEndOcclusionQueryNV)
        UCT.glEndOcclusionQueryNV();
    CHECK_GL_CALL(glEndOcclusionQueryNV)
        JT.glEndOcclusionQueryNV();
}

void STUB_glEndPerfMonitorAMD( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glEndPerfMonitorAMD( GLuint )
    maxParam = 1;
    READ_ENUM_PARAM(0);
    TR.skipLine();
    CHECK_USER_CALL(glEndPerfMonitorAMD)
        UCT.glEndPerfMonitorAMD(param[0].uv32bit);
    CHECK_GL_CALL(glEndPerfMonitorAMD)
        JT.glEndPerfMonitorAMD(param[0].uv32bit);
}

void STUB_glEndQuery( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glEndQuery( GLenum )
    maxParam = 1;
    READ_ENUM_PARAM(0);
    TR.skipLine();
    CHECK_USER_CALL(glEndQuery)
        UCT.glEndQuery(param[0].uv32bit);
    CHECK_GL_CALL(glEndQuery)
        JT.glEndQuery(param[0].uv32bit);
}

void STUB_glEndQueryARB( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glEndQueryARB( GLenum )
    maxParam = 1;
    READ_ENUM_PARAM(0);
    TR.skipLine();
    CHECK_USER_CALL(glEndQueryARB)
        UCT.glEndQueryARB(param[0].uv32bit);
    CHECK_GL_CALL(glEndQueryARB)
        JT.glEndQueryARB(param[0].uv32bit);
}

void STUB_glEndTransformFeedback( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glEndTransformFeedback(  )
    maxParam = 0;
    TR.skipLine();
    CHECK_USER_CALL(glEndTransformFeedback)
        UCT.glEndTransformFeedback();
    CHECK_GL_CALL(glEndTransformFeedback)
        JT.glEndTransformFeedback();
}

void STUB_glEndTransformFeedbackEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glEndTransformFeedbackEXT(  )
    maxParam = 0;
    TR.skipLine();
    CHECK_USER_CALL(glEndTransformFeedbackEXT)
        UCT.glEndTransformFeedbackEXT();
    CHECK_GL_CALL(glEndTransformFeedbackEXT)
        JT.glEndTransformFeedbackEXT();
}

void STUB_glEndTransformFeedbackNV( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glEndTransformFeedbackNV(  )
    maxParam = 0;
    TR.skipLine();
    CHECK_USER_CALL(glEndTransformFeedbackNV)
        UCT.glEndTransformFeedbackNV();
    CHECK_GL_CALL(glEndTransformFeedbackNV)
        JT.glEndTransformFeedbackNV();
}

void STUB_glEndVertexShaderEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glEndVertexShaderEXT(  )
    maxParam = 0;
    TR.skipLine();
    CHECK_USER_CALL(glEndVertexShaderEXT)
        UCT.glEndVertexShaderEXT();
    CHECK_GL_CALL(glEndVertexShaderEXT)
        JT.glEndVertexShaderEXT();
}

void STUB_glEvalCoord1d( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glEvalCoord1d( GLdouble u )
    maxParam = 1;
    READ_DOUBLE_PARAM(0);
    TR.skipLine();
    CHECK_USER_CALL(glEvalCoord1d)
        UCT.glEvalCoord1d(param[0].fv64bit);
    CHECK_GL_CALL(glEvalCoord1d)
        JT.glEvalCoord1d(param[0].fv64bit);
}

void STUB_glEvalCoord1dv( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glEvalCoord1dv( const GLdouble *u )
    maxParam = 1;
    char buffer0[16*4096];
    READ_ARRAY_PARAM( 0, buffer0, TraceReader::TEXT_DOUBLE);
    TR.skipLine();
    CHECK_USER_CALL(glEvalCoord1dv)
        UCT.glEvalCoord1dv((const GLdouble *)param[0].ptr);
    CHECK_GL_CALL(glEvalCoord1dv)
        JT.glEvalCoord1dv((const GLdouble *)param[0].ptr);
}

void STUB_glEvalCoord1f( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glEvalCoord1f( GLfloat u )
    maxParam = 1;
    READ_PARAM(fv32bit,0);
    TR.skipLine();
    CHECK_USER_CALL(glEvalCoord1f)
        UCT.glEvalCoord1f(param[0].fv32bit);
    CHECK_GL_CALL(glEvalCoord1f)
        JT.glEvalCoord1f(param[0].fv32bit);
}

void STUB_glEvalCoord1fv( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glEvalCoord1fv( const GLfloat *u )
    maxParam = 1;
    char buffer0[16*4096];
    READ_ARRAY_PARAM( 0, buffer0, TraceReader::TEXT_FLOAT);
    TR.skipLine();
    CHECK_USER_CALL(glEvalCoord1fv)
        UCT.glEvalCoord1fv((const GLfloat *)param[0].ptr);
    CHECK_GL_CALL(glEvalCoord1fv)
        JT.glEvalCoord1fv((const GLfloat *)param[0].ptr);
}

void STUB_glEvalCoord2d( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glEvalCoord2d( GLdouble u, GLdouble v )
    maxParam = 2;
    READ_DOUBLE_PARAM(0);
    READ_DOUBLE_PARAM(1);
    TR.skipLine();
    CHECK_USER_CALL(glEvalCoord2d)
        UCT.glEvalCoord2d(param[0].fv64bit, param[1].fv64bit);
    CHECK_GL_CALL(glEvalCoord2d)
        JT.glEvalCoord2d(param[0].fv64bit, param[1].fv64bit);
}

void STUB_glEvalCoord2dv( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glEvalCoord2dv( const GLdouble *u )
    maxParam = 1;
    char buffer0[16*4096];
    READ_ARRAY_PARAM( 0, buffer0, TraceReader::TEXT_DOUBLE);
    TR.skipLine();
    CHECK_USER_CALL(glEvalCoord2dv)
        UCT.glEvalCoord2dv((const GLdouble *)param[0].ptr);
    CHECK_GL_CALL(glEvalCoord2dv)
        JT.glEvalCoord2dv((const GLdouble *)param[0].ptr);
}

void STUB_glEvalCoord2f( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glEvalCoord2f( GLfloat u, GLfloat v )
    maxParam = 2;
    READ_PARAM(fv32bit,0);
    READ_PARAM(fv32bit,1);
    TR.skipLine();
    CHECK_USER_CALL(glEvalCoord2f)
        UCT.glEvalCoord2f(param[0].fv32bit, param[1].fv32bit);
    CHECK_GL_CALL(glEvalCoord2f)
        JT.glEvalCoord2f(param[0].fv32bit, param[1].fv32bit);
}

void STUB_glEvalCoord2fv( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glEvalCoord2fv( const GLfloat *u )
    maxParam = 1;
    char buffer0[16*4096];
    READ_ARRAY_PARAM( 0, buffer0, TraceReader::TEXT_FLOAT);
    TR.skipLine();
    CHECK_USER_CALL(glEvalCoord2fv)
        UCT.glEvalCoord2fv((const GLfloat *)param[0].ptr);
    CHECK_GL_CALL(glEvalCoord2fv)
        JT.glEvalCoord2fv((const GLfloat *)param[0].ptr);
}

void STUB_glEvalMapsNV( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glEvalMapsNV( GLenum, GLenum )
    maxParam = 2;
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    TR.skipLine();
    CHECK_USER_CALL(glEvalMapsNV)
        UCT.glEvalMapsNV(param[0].uv32bit, param[1].uv32bit);
    CHECK_GL_CALL(glEvalMapsNV)
        JT.glEvalMapsNV(param[0].uv32bit, param[1].uv32bit);
}

void STUB_glEvalMesh1( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glEvalMesh1( GLenum mode, GLint i1, GLint i2 )
    maxParam = 3;
    READ_ENUM_PARAM(0);
    READ_PARAM(v32bit,1);
    READ_PARAM(v32bit,2);
    TR.skipLine();
    CHECK_USER_CALL(glEvalMesh1)
        UCT.glEvalMesh1(param[0].uv32bit, param[1].v32bit, param[2].v32bit);
    CHECK_GL_CALL(glEvalMesh1)
        JT.glEvalMesh1(param[0].uv32bit, param[1].v32bit, param[2].v32bit);
}

void STUB_glEvalMesh2( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glEvalMesh2( GLenum mode, GLint i1, GLint i2, GLint j1, GLint j2 )
    maxParam = 5;
    READ_ENUM_PARAM(0);
    READ_PARAM(v32bit,1);
    READ_PARAM(v32bit,2);
    READ_PARAM(v32bit,3);
    READ_PARAM(v32bit,4);
    TR.skipLine();
    CHECK_USER_CALL(glEvalMesh2)
        UCT.glEvalMesh2(param[0].uv32bit, param[1].v32bit, param[2].v32bit, param[3].v32bit, param[4].v32bit);
    CHECK_GL_CALL(glEvalMesh2)
        JT.glEvalMesh2(param[0].uv32bit, param[1].v32bit, param[2].v32bit, param[3].v32bit, param[4].v32bit);
}

void STUB_glEvalPoint1( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glEvalPoint1( GLint i )
    maxParam = 1;
    READ_PARAM(v32bit,0);
    TR.skipLine();
    CHECK_USER_CALL(glEvalPoint1)
        UCT.glEvalPoint1(param[0].v32bit);
    CHECK_GL_CALL(glEvalPoint1)
        JT.glEvalPoint1(param[0].v32bit);
}

void STUB_glEvalPoint2( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glEvalPoint2( GLint i, GLint j )
    maxParam = 2;
    READ_PARAM(v32bit,0);
    READ_PARAM(v32bit,1);
    TR.skipLine();
    CHECK_USER_CALL(glEvalPoint2)
        UCT.glEvalPoint2(param[0].v32bit, param[1].v32bit);
    CHECK_GL_CALL(glEvalPoint2)
        JT.glEvalPoint2(param[0].v32bit, param[1].v32bit);
}

void STUB_glExecuteProgramNV( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glExecuteProgramNV( GLenum, GLuint, const GLfloat * )
    maxParam = 3;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_ARRAY_PARAM( 2, buffer0, TraceReader::TEXT_FLOAT);
    TR.skipLine();
    CHECK_USER_CALL(glExecuteProgramNV)
        UCT.glExecuteProgramNV(param[0].uv32bit, param[1].uv32bit, (const GLfloat *)param[2].ptr);
    CHECK_GL_CALL(glExecuteProgramNV)
        JT.glExecuteProgramNV(param[0].uv32bit, param[1].uv32bit, (const GLfloat *)param[2].ptr);
}

void STUB_glExtractComponentEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glExtractComponentEXT( GLuint, GLuint, GLuint )
    maxParam = 3;
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_ENUM_PARAM(2);
    TR.skipLine();
    CHECK_USER_CALL(glExtractComponentEXT)
        UCT.glExtractComponentEXT(param[0].uv32bit, param[1].uv32bit, param[2].uv32bit);
    CHECK_GL_CALL(glExtractComponentEXT)
        JT.glExtractComponentEXT(param[0].uv32bit, param[1].uv32bit, param[2].uv32bit);
}

void STUB_glFeedbackBuffer( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glFeedbackBuffer( GLsizei size, GLenum type, GLfloat *buffer )
    maxParam = 3;
    char buffer0[16*4096];
    READ_PARAM(v32bit,0);
    READ_ENUM_PARAM(1);
    READ_ARRAY_PARAM( 2, buffer0, TraceReader::TEXT_FLOAT);
    TR.skipLine();
    CHECK_USER_CALL(glFeedbackBuffer)
        UCT.glFeedbackBuffer(param[0].v32bit, param[1].uv32bit, (GLfloat *)param[2].ptr);
    CHECK_GL_CALL(glFeedbackBuffer)
        JT.glFeedbackBuffer(param[0].v32bit, param[1].uv32bit, (GLfloat *)param[2].ptr);
}

void STUB_glFinalCombinerInputNV( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glFinalCombinerInputNV( GLenum, GLenum, GLenum, GLenum )
    maxParam = 4;
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_ENUM_PARAM(2);
    READ_ENUM_PARAM(3);
    TR.skipLine();
    CHECK_USER_CALL(glFinalCombinerInputNV)
        UCT.glFinalCombinerInputNV(param[0].uv32bit, param[1].uv32bit, param[2].uv32bit, param[3].uv32bit);
    CHECK_GL_CALL(glFinalCombinerInputNV)
        JT.glFinalCombinerInputNV(param[0].uv32bit, param[1].uv32bit, param[2].uv32bit, param[3].uv32bit);
}

void STUB_glFinish( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glFinish(  )
    maxParam = 0;
    TR.skipLine();
    CHECK_USER_CALL(glFinish)
        UCT.glFinish();
    CHECK_GL_CALL(glFinish)
        JT.glFinish();
}

void STUB_glFinishAsyncSGIX( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // GLint glFinishAsyncSGIX( GLuint * )
    maxParam = 1;
    char buffer0[16*4096];
    READ_ARRAY_PARAM( 0, buffer0, TraceReader::TEXT_INT);
    TR.skipResult();
    TR.skipLine();
    CHECK_USER_CALL(glFinishAsyncSGIX)
        UCT.glFinishAsyncSGIX((GLuint *)param[0].ptr);
    CHECK_GL_CALL(glFinishAsyncSGIX)
        JT.glFinishAsyncSGIX((GLuint *)param[0].ptr);
}

void STUB_glFinishFenceAPPLE( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glFinishFenceAPPLE( GLuint )
    maxParam = 1;
    READ_ENUM_PARAM(0);
    TR.skipLine();
    CHECK_USER_CALL(glFinishFenceAPPLE)
        UCT.glFinishFenceAPPLE(param[0].uv32bit);
    CHECK_GL_CALL(glFinishFenceAPPLE)
        JT.glFinishFenceAPPLE(param[0].uv32bit);
}

void STUB_glFinishFenceNV( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glFinishFenceNV( GLuint )
    maxParam = 1;
    READ_ENUM_PARAM(0);
    TR.skipLine();
    CHECK_USER_CALL(glFinishFenceNV)
        UCT.glFinishFenceNV(param[0].uv32bit);
    CHECK_GL_CALL(glFinishFenceNV)
        JT.glFinishFenceNV(param[0].uv32bit);
}

void STUB_glFinishObjectAPPLE( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glFinishObjectAPPLE( GLenum, GLint )
    maxParam = 2;
    READ_ENUM_PARAM(0);
    READ_PARAM(v32bit,1);
    TR.skipLine();
    CHECK_USER_CALL(glFinishObjectAPPLE)
        UCT.glFinishObjectAPPLE(param[0].uv32bit, param[1].v32bit);
    CHECK_GL_CALL(glFinishObjectAPPLE)
        JT.glFinishObjectAPPLE(param[0].uv32bit, param[1].v32bit);
}

void STUB_glFlush( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glFlush(  )
    maxParam = 0;
    TR.skipLine();
    CHECK_USER_CALL(glFlush)
        UCT.glFlush();
    CHECK_GL_CALL(glFlush)
        JT.glFlush();
}

void STUB_glFlushMappedBufferRange( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glFlushMappedBufferRange( GLenum, GLintptr, GLsizeiptr )
    maxParam = 3;
    READ_ENUM_PARAM(0);
    READ_PARAM(v32bit,1);
    READ_PARAM(v32bit,2);
    TR.skipLine();
    CHECK_USER_CALL(glFlushMappedBufferRange)
        UCT.glFlushMappedBufferRange(param[0].uv32bit, param[1].v32bit, param[2].v32bit);
    CHECK_GL_CALL(glFlushMappedBufferRange)
        JT.glFlushMappedBufferRange(param[0].uv32bit, param[1].v32bit, param[2].v32bit);
}

void STUB_glFlushMappedBufferRangeAPPLE( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glFlushMappedBufferRangeAPPLE( GLenum, GLintptr, GLsizeiptr )
    maxParam = 3;
    READ_ENUM_PARAM(0);
    READ_PARAM(v32bit,1);
    READ_PARAM(v32bit,2);
    TR.skipLine();
    CHECK_USER_CALL(glFlushMappedBufferRangeAPPLE)
        UCT.glFlushMappedBufferRangeAPPLE(param[0].uv32bit, param[1].v32bit, param[2].v32bit);
    CHECK_GL_CALL(glFlushMappedBufferRangeAPPLE)
        JT.glFlushMappedBufferRangeAPPLE(param[0].uv32bit, param[1].v32bit, param[2].v32bit);
}

void STUB_glFlushPixelDataRangeNV( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glFlushPixelDataRangeNV( GLenum )
    maxParam = 1;
    READ_ENUM_PARAM(0);
    TR.skipLine();
    CHECK_USER_CALL(glFlushPixelDataRangeNV)
        UCT.glFlushPixelDataRangeNV(param[0].uv32bit);
    CHECK_GL_CALL(glFlushPixelDataRangeNV)
        JT.glFlushPixelDataRangeNV(param[0].uv32bit);
}

void STUB_glFlushRasterSGIX( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glFlushRasterSGIX(  )
    maxParam = 0;
    TR.skipLine();
    CHECK_USER_CALL(glFlushRasterSGIX)
        UCT.glFlushRasterSGIX();
    CHECK_GL_CALL(glFlushRasterSGIX)
        JT.glFlushRasterSGIX();
}

void STUB_glFlushVertexArrayRangeAPPLE( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glFlushVertexArrayRangeAPPLE( GLsizei, GLvoid * )
    maxParam = 2;
    char buffer0[16*4096];
    READ_PARAM(v32bit,0);
    READ_ARRAY_PARAM( 1, buffer0, TraceReader::TEXT_IGNORE);
    TR.skipLine();
    CHECK_USER_CALL(glFlushVertexArrayRangeAPPLE)
        UCT.glFlushVertexArrayRangeAPPLE(param[0].v32bit, (GLvoid *)param[1].ptr);
    CHECK_GL_CALL(glFlushVertexArrayRangeAPPLE)
        JT.glFlushVertexArrayRangeAPPLE(param[0].v32bit, (GLvoid *)param[1].ptr);
}

void STUB_glFlushVertexArrayRangeNV( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glFlushVertexArrayRangeNV(  )
    maxParam = 0;
    TR.skipLine();
    CHECK_USER_CALL(glFlushVertexArrayRangeNV)
        UCT.glFlushVertexArrayRangeNV();
    CHECK_GL_CALL(glFlushVertexArrayRangeNV)
        JT.glFlushVertexArrayRangeNV();
}

void STUB_glFogCoordPointer( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glFogCoordPointer( GLenum, GLsizei, const GLvoid * )
    maxParam = 3;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_PARAM(v32bit,1);
    READ_ARRAY_PARAM( 2, buffer0, TraceReader::TEXT_IGNORE);
    TR.skipLine();
    CHECK_USER_CALL(glFogCoordPointer)
        UCT.glFogCoordPointer(param[0].uv32bit, param[1].v32bit, (const GLvoid *)param[2].ptr);
    CHECK_GL_CALL(glFogCoordPointer)
        JT.glFogCoordPointer(param[0].uv32bit, param[1].v32bit, (const GLvoid *)param[2].ptr);
}

void STUB_glFogCoordPointerEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glFogCoordPointerEXT( GLenum, GLsizei, const GLvoid * )
    maxParam = 3;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_PARAM(v32bit,1);
    READ_ARRAY_PARAM( 2, buffer0, TraceReader::TEXT_IGNORE);
    TR.skipLine();
    CHECK_USER_CALL(glFogCoordPointerEXT)
        UCT.glFogCoordPointerEXT(param[0].uv32bit, param[1].v32bit, (const GLvoid *)param[2].ptr);
    CHECK_GL_CALL(glFogCoordPointerEXT)
        JT.glFogCoordPointerEXT(param[0].uv32bit, param[1].v32bit, (const GLvoid *)param[2].ptr);
}

void STUB_glFogCoordd( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glFogCoordd( GLdouble )
    maxParam = 1;
    READ_DOUBLE_PARAM(0);
    TR.skipLine();
    CHECK_USER_CALL(glFogCoordd)
        UCT.glFogCoordd(param[0].fv64bit);
    CHECK_GL_CALL(glFogCoordd)
        JT.glFogCoordd(param[0].fv64bit);
}

void STUB_glFogCoorddEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glFogCoorddEXT( GLdouble )
    maxParam = 1;
    READ_DOUBLE_PARAM(0);
    TR.skipLine();
    CHECK_USER_CALL(glFogCoorddEXT)
        UCT.glFogCoorddEXT(param[0].fv64bit);
    CHECK_GL_CALL(glFogCoorddEXT)
        JT.glFogCoorddEXT(param[0].fv64bit);
}

void STUB_glFogCoorddv( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glFogCoorddv( const GLdouble * )
    maxParam = 1;
    char buffer0[16*4096];
    READ_ARRAY_PARAM( 0, buffer0, TraceReader::TEXT_DOUBLE);
    TR.skipLine();
    CHECK_USER_CALL(glFogCoorddv)
        UCT.glFogCoorddv((const GLdouble *)param[0].ptr);
    CHECK_GL_CALL(glFogCoorddv)
        JT.glFogCoorddv((const GLdouble *)param[0].ptr);
}

void STUB_glFogCoorddvEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glFogCoorddvEXT( const GLdouble * )
    maxParam = 1;
    char buffer0[16*4096];
    READ_ARRAY_PARAM( 0, buffer0, TraceReader::TEXT_DOUBLE);
    TR.skipLine();
    CHECK_USER_CALL(glFogCoorddvEXT)
        UCT.glFogCoorddvEXT((const GLdouble *)param[0].ptr);
    CHECK_GL_CALL(glFogCoorddvEXT)
        JT.glFogCoorddvEXT((const GLdouble *)param[0].ptr);
}

void STUB_glFogCoordf( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glFogCoordf( GLfloat )
    maxParam = 1;
    READ_PARAM(fv32bit,0);
    TR.skipLine();
    CHECK_USER_CALL(glFogCoordf)
        UCT.glFogCoordf(param[0].fv32bit);
    CHECK_GL_CALL(glFogCoordf)
        JT.glFogCoordf(param[0].fv32bit);
}

void STUB_glFogCoordfEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glFogCoordfEXT( GLfloat )
    maxParam = 1;
    READ_PARAM(fv32bit,0);
    TR.skipLine();
    CHECK_USER_CALL(glFogCoordfEXT)
        UCT.glFogCoordfEXT(param[0].fv32bit);
    CHECK_GL_CALL(glFogCoordfEXT)
        JT.glFogCoordfEXT(param[0].fv32bit);
}

void STUB_glFogCoordfv( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glFogCoordfv( const GLfloat * )
    maxParam = 1;
    char buffer0[16*4096];
    READ_ARRAY_PARAM( 0, buffer0, TraceReader::TEXT_FLOAT);
    TR.skipLine();
    CHECK_USER_CALL(glFogCoordfv)
        UCT.glFogCoordfv((const GLfloat *)param[0].ptr);
    CHECK_GL_CALL(glFogCoordfv)
        JT.glFogCoordfv((const GLfloat *)param[0].ptr);
}

void STUB_glFogCoordfvEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glFogCoordfvEXT( const GLfloat * )
    maxParam = 1;
    char buffer0[16*4096];
    READ_ARRAY_PARAM( 0, buffer0, TraceReader::TEXT_FLOAT);
    TR.skipLine();
    CHECK_USER_CALL(glFogCoordfvEXT)
        UCT.glFogCoordfvEXT((const GLfloat *)param[0].ptr);
    CHECK_GL_CALL(glFogCoordfvEXT)
        JT.glFogCoordfvEXT((const GLfloat *)param[0].ptr);
}

void STUB_glFogCoordhNV( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glFogCoordhNV( GLhalfNV )
    // Call not playable
    TR.skipCall();
}

void STUB_glFogCoordhvNV( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glFogCoordhvNV( const GLhalfNV * )
    // Call not playable
    TR.skipCall();
}

void STUB_glFogFuncSGIS( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glFogFuncSGIS( GLsizei, const GLfloat * )
    maxParam = 2;
    char buffer0[16*4096];
    READ_PARAM(v32bit,0);
    READ_ARRAY_PARAM( 1, buffer0, TraceReader::TEXT_FLOAT);
    TR.skipLine();
    CHECK_USER_CALL(glFogFuncSGIS)
        UCT.glFogFuncSGIS(param[0].v32bit, (const GLfloat *)param[1].ptr);
    CHECK_GL_CALL(glFogFuncSGIS)
        JT.glFogFuncSGIS(param[0].v32bit, (const GLfloat *)param[1].ptr);
}

void STUB_glFogf( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glFogf( GLenum pname, GLfloat param )
    maxParam = 2;
    READ_ENUM_PARAM(0);
    READ_PARAM(fv32bit,1);
    TR.skipLine();
    CHECK_USER_CALL(glFogf)
        UCT.glFogf(param[0].uv32bit, param[1].fv32bit);
    CHECK_GL_CALL(glFogf)
        JT.glFogf(param[0].uv32bit, param[1].fv32bit);
}

void STUB_glFogfv( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glFogfv( GLenum pname, const GLfloat *params )
    maxParam = 2;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ARRAY_PARAM( 1, buffer0, TraceReader::TEXT_FLOAT);
    TR.skipLine();
    CHECK_USER_CALL(glFogfv)
        UCT.glFogfv(param[0].uv32bit, (const GLfloat *)param[1].ptr);
    CHECK_GL_CALL(glFogfv)
        JT.glFogfv(param[0].uv32bit, (const GLfloat *)param[1].ptr);
}

void STUB_glFogi( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glFogi( GLenum pname, GLint param )
    maxParam = 2;
    READ_ENUM_PARAM(0);
    READ_PARAM(v32bit,1);
    TR.skipLine();
    CHECK_USER_CALL(glFogi)
        UCT.glFogi(param[0].uv32bit, param[1].v32bit);
    CHECK_GL_CALL(glFogi)
        JT.glFogi(param[0].uv32bit, param[1].v32bit);
}

void STUB_glFogiv( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glFogiv( GLenum pname, const GLint *params )
    maxParam = 2;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ARRAY_PARAM( 1, buffer0, TraceReader::TEXT_INT);
    TR.skipLine();
    CHECK_USER_CALL(glFogiv)
        UCT.glFogiv(param[0].uv32bit, (const GLint *)param[1].ptr);
    CHECK_GL_CALL(glFogiv)
        JT.glFogiv(param[0].uv32bit, (const GLint *)param[1].ptr);
}

void STUB_glFragmentColorMaterialSGIX( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glFragmentColorMaterialSGIX( GLenum, GLenum )
    maxParam = 2;
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    TR.skipLine();
    CHECK_USER_CALL(glFragmentColorMaterialSGIX)
        UCT.glFragmentColorMaterialSGIX(param[0].uv32bit, param[1].uv32bit);
    CHECK_GL_CALL(glFragmentColorMaterialSGIX)
        JT.glFragmentColorMaterialSGIX(param[0].uv32bit, param[1].uv32bit);
}

void STUB_glFragmentLightModelfSGIX( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glFragmentLightModelfSGIX( GLenum, GLfloat )
    maxParam = 2;
    READ_ENUM_PARAM(0);
    READ_PARAM(fv32bit,1);
    TR.skipLine();
    CHECK_USER_CALL(glFragmentLightModelfSGIX)
        UCT.glFragmentLightModelfSGIX(param[0].uv32bit, param[1].fv32bit);
    CHECK_GL_CALL(glFragmentLightModelfSGIX)
        JT.glFragmentLightModelfSGIX(param[0].uv32bit, param[1].fv32bit);
}

void STUB_glFragmentLightModelfvSGIX( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glFragmentLightModelfvSGIX( GLenum, const GLfloat * )
    maxParam = 2;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ARRAY_PARAM( 1, buffer0, TraceReader::TEXT_FLOAT);
    TR.skipLine();
    CHECK_USER_CALL(glFragmentLightModelfvSGIX)
        UCT.glFragmentLightModelfvSGIX(param[0].uv32bit, (const GLfloat *)param[1].ptr);
    CHECK_GL_CALL(glFragmentLightModelfvSGIX)
        JT.glFragmentLightModelfvSGIX(param[0].uv32bit, (const GLfloat *)param[1].ptr);
}

void STUB_glFragmentLightModeliSGIX( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glFragmentLightModeliSGIX( GLenum, GLint )
    maxParam = 2;
    READ_ENUM_PARAM(0);
    READ_PARAM(v32bit,1);
    TR.skipLine();
    CHECK_USER_CALL(glFragmentLightModeliSGIX)
        UCT.glFragmentLightModeliSGIX(param[0].uv32bit, param[1].v32bit);
    CHECK_GL_CALL(glFragmentLightModeliSGIX)
        JT.glFragmentLightModeliSGIX(param[0].uv32bit, param[1].v32bit);
}

void STUB_glFragmentLightModelivSGIX( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glFragmentLightModelivSGIX( GLenum, const GLint * )
    maxParam = 2;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ARRAY_PARAM( 1, buffer0, TraceReader::TEXT_INT);
    TR.skipLine();
    CHECK_USER_CALL(glFragmentLightModelivSGIX)
        UCT.glFragmentLightModelivSGIX(param[0].uv32bit, (const GLint *)param[1].ptr);
    CHECK_GL_CALL(glFragmentLightModelivSGIX)
        JT.glFragmentLightModelivSGIX(param[0].uv32bit, (const GLint *)param[1].ptr);
}

void STUB_glFragmentLightfSGIX( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glFragmentLightfSGIX( GLenum, GLenum, GLfloat )
    maxParam = 3;
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_PARAM(fv32bit,2);
    TR.skipLine();
    CHECK_USER_CALL(glFragmentLightfSGIX)
        UCT.glFragmentLightfSGIX(param[0].uv32bit, param[1].uv32bit, param[2].fv32bit);
    CHECK_GL_CALL(glFragmentLightfSGIX)
        JT.glFragmentLightfSGIX(param[0].uv32bit, param[1].uv32bit, param[2].fv32bit);
}

void STUB_glFragmentLightfvSGIX( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glFragmentLightfvSGIX( GLenum, GLenum, const GLfloat * )
    maxParam = 3;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_ARRAY_PARAM( 2, buffer0, TraceReader::TEXT_FLOAT);
    TR.skipLine();
    CHECK_USER_CALL(glFragmentLightfvSGIX)
        UCT.glFragmentLightfvSGIX(param[0].uv32bit, param[1].uv32bit, (const GLfloat *)param[2].ptr);
    CHECK_GL_CALL(glFragmentLightfvSGIX)
        JT.glFragmentLightfvSGIX(param[0].uv32bit, param[1].uv32bit, (const GLfloat *)param[2].ptr);
}

void STUB_glFragmentLightiSGIX( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glFragmentLightiSGIX( GLenum, GLenum, GLint )
    maxParam = 3;
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_PARAM(v32bit,2);
    TR.skipLine();
    CHECK_USER_CALL(glFragmentLightiSGIX)
        UCT.glFragmentLightiSGIX(param[0].uv32bit, param[1].uv32bit, param[2].v32bit);
    CHECK_GL_CALL(glFragmentLightiSGIX)
        JT.glFragmentLightiSGIX(param[0].uv32bit, param[1].uv32bit, param[2].v32bit);
}

void STUB_glFragmentLightivSGIX( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glFragmentLightivSGIX( GLenum, GLenum, const GLint * )
    maxParam = 3;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_ARRAY_PARAM( 2, buffer0, TraceReader::TEXT_INT);
    TR.skipLine();
    CHECK_USER_CALL(glFragmentLightivSGIX)
        UCT.glFragmentLightivSGIX(param[0].uv32bit, param[1].uv32bit, (const GLint *)param[2].ptr);
    CHECK_GL_CALL(glFragmentLightivSGIX)
        JT.glFragmentLightivSGIX(param[0].uv32bit, param[1].uv32bit, (const GLint *)param[2].ptr);
}

void STUB_glFragmentMaterialfSGIX( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glFragmentMaterialfSGIX( GLenum, GLenum, GLfloat )
    maxParam = 3;
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_PARAM(fv32bit,2);
    TR.skipLine();
    CHECK_USER_CALL(glFragmentMaterialfSGIX)
        UCT.glFragmentMaterialfSGIX(param[0].uv32bit, param[1].uv32bit, param[2].fv32bit);
    CHECK_GL_CALL(glFragmentMaterialfSGIX)
        JT.glFragmentMaterialfSGIX(param[0].uv32bit, param[1].uv32bit, param[2].fv32bit);
}

void STUB_glFragmentMaterialfvSGIX( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glFragmentMaterialfvSGIX( GLenum, GLenum, const GLfloat * )
    maxParam = 3;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_ARRAY_PARAM( 2, buffer0, TraceReader::TEXT_FLOAT);
    TR.skipLine();
    CHECK_USER_CALL(glFragmentMaterialfvSGIX)
        UCT.glFragmentMaterialfvSGIX(param[0].uv32bit, param[1].uv32bit, (const GLfloat *)param[2].ptr);
    CHECK_GL_CALL(glFragmentMaterialfvSGIX)
        JT.glFragmentMaterialfvSGIX(param[0].uv32bit, param[1].uv32bit, (const GLfloat *)param[2].ptr);
}

void STUB_glFragmentMaterialiSGIX( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glFragmentMaterialiSGIX( GLenum, GLenum, GLint )
    maxParam = 3;
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_PARAM(v32bit,2);
    TR.skipLine();
    CHECK_USER_CALL(glFragmentMaterialiSGIX)
        UCT.glFragmentMaterialiSGIX(param[0].uv32bit, param[1].uv32bit, param[2].v32bit);
    CHECK_GL_CALL(glFragmentMaterialiSGIX)
        JT.glFragmentMaterialiSGIX(param[0].uv32bit, param[1].uv32bit, param[2].v32bit);
}

void STUB_glFragmentMaterialivSGIX( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glFragmentMaterialivSGIX( GLenum, GLenum, const GLint * )
    maxParam = 3;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_ARRAY_PARAM( 2, buffer0, TraceReader::TEXT_INT);
    TR.skipLine();
    CHECK_USER_CALL(glFragmentMaterialivSGIX)
        UCT.glFragmentMaterialivSGIX(param[0].uv32bit, param[1].uv32bit, (const GLint *)param[2].ptr);
    CHECK_GL_CALL(glFragmentMaterialivSGIX)
        JT.glFragmentMaterialivSGIX(param[0].uv32bit, param[1].uv32bit, (const GLint *)param[2].ptr);
}

void STUB_glFrameTerminatorGREMEDY( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glFrameTerminatorGREMEDY(  )
    maxParam = 0;
    TR.skipLine();
    CHECK_USER_CALL(glFrameTerminatorGREMEDY)
        UCT.glFrameTerminatorGREMEDY();
    CHECK_GL_CALL(glFrameTerminatorGREMEDY)
        JT.glFrameTerminatorGREMEDY();
}

void STUB_glFrameZoomSGIX( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glFrameZoomSGIX( GLint )
    maxParam = 1;
    READ_PARAM(v32bit,0);
    TR.skipLine();
    CHECK_USER_CALL(glFrameZoomSGIX)
        UCT.glFrameZoomSGIX(param[0].v32bit);
    CHECK_GL_CALL(glFrameZoomSGIX)
        JT.glFrameZoomSGIX(param[0].v32bit);
}

void STUB_glFramebufferDrawBufferEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glFramebufferDrawBufferEXT( GLuint, GLenum )
    maxParam = 2;
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    TR.skipLine();
    CHECK_USER_CALL(glFramebufferDrawBufferEXT)
        UCT.glFramebufferDrawBufferEXT(param[0].uv32bit, param[1].uv32bit);
    CHECK_GL_CALL(glFramebufferDrawBufferEXT)
        JT.glFramebufferDrawBufferEXT(param[0].uv32bit, param[1].uv32bit);
}

void STUB_glFramebufferDrawBuffersEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glFramebufferDrawBuffersEXT( GLuint, GLsizei, const GLenum * )
    maxParam = 3;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_PARAM(v32bit,1);
    READ_ARRAY_PARAM( 2, buffer0, TraceReader::TEXT_INT);
    TR.skipLine();
    CHECK_USER_CALL(glFramebufferDrawBuffersEXT)
        UCT.glFramebufferDrawBuffersEXT(param[0].uv32bit, param[1].v32bit, (const GLenum *)param[2].ptr);
    CHECK_GL_CALL(glFramebufferDrawBuffersEXT)
        JT.glFramebufferDrawBuffersEXT(param[0].uv32bit, param[1].v32bit, (const GLenum *)param[2].ptr);
}

void STUB_glFramebufferReadBufferEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glFramebufferReadBufferEXT( GLuint, GLenum )
    maxParam = 2;
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    TR.skipLine();
    CHECK_USER_CALL(glFramebufferReadBufferEXT)
        UCT.glFramebufferReadBufferEXT(param[0].uv32bit, param[1].uv32bit);
    CHECK_GL_CALL(glFramebufferReadBufferEXT)
        JT.glFramebufferReadBufferEXT(param[0].uv32bit, param[1].uv32bit);
}

void STUB_glFramebufferRenderbuffer( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glFramebufferRenderbuffer( GLenum, GLenum, GLenum, GLuint )
    maxParam = 4;
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_ENUM_PARAM(2);
    READ_ENUM_PARAM(3);
    TR.skipLine();
    CHECK_USER_CALL(glFramebufferRenderbuffer)
        UCT.glFramebufferRenderbuffer(param[0].uv32bit, param[1].uv32bit, param[2].uv32bit, param[3].uv32bit);
    CHECK_GL_CALL(glFramebufferRenderbuffer)
        JT.glFramebufferRenderbuffer(param[0].uv32bit, param[1].uv32bit, param[2].uv32bit, param[3].uv32bit);
}

void STUB_glFramebufferRenderbufferEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glFramebufferRenderbufferEXT( GLenum, GLenum, GLenum, GLuint )
    maxParam = 4;
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_ENUM_PARAM(2);
    READ_ENUM_PARAM(3);
    TR.skipLine();
    CHECK_USER_CALL(glFramebufferRenderbufferEXT)
        UCT.glFramebufferRenderbufferEXT(param[0].uv32bit, param[1].uv32bit, param[2].uv32bit, param[3].uv32bit);
    CHECK_GL_CALL(glFramebufferRenderbufferEXT)
        JT.glFramebufferRenderbufferEXT(param[0].uv32bit, param[1].uv32bit, param[2].uv32bit, param[3].uv32bit);
}

void STUB_glFramebufferTexture1D( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glFramebufferTexture1D( GLenum, GLenum, GLenum, GLuint, GLint )
    maxParam = 5;
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_ENUM_PARAM(2);
    READ_ENUM_PARAM(3);
    READ_PARAM(v32bit,4);
    TR.skipLine();
    CHECK_USER_CALL(glFramebufferTexture1D)
        UCT.glFramebufferTexture1D(param[0].uv32bit, param[1].uv32bit, param[2].uv32bit, param[3].uv32bit, param[4].v32bit);
    CHECK_GL_CALL(glFramebufferTexture1D)
        JT.glFramebufferTexture1D(param[0].uv32bit, param[1].uv32bit, param[2].uv32bit, param[3].uv32bit, param[4].v32bit);
}

void STUB_glFramebufferTexture1DEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glFramebufferTexture1DEXT( GLenum, GLenum, GLenum, GLuint, GLint )
    maxParam = 5;
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_ENUM_PARAM(2);
    READ_ENUM_PARAM(3);
    READ_PARAM(v32bit,4);
    TR.skipLine();
    CHECK_USER_CALL(glFramebufferTexture1DEXT)
        UCT.glFramebufferTexture1DEXT(param[0].uv32bit, param[1].uv32bit, param[2].uv32bit, param[3].uv32bit, param[4].v32bit);
    CHECK_GL_CALL(glFramebufferTexture1DEXT)
        JT.glFramebufferTexture1DEXT(param[0].uv32bit, param[1].uv32bit, param[2].uv32bit, param[3].uv32bit, param[4].v32bit);
}

void STUB_glFramebufferTexture2D( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glFramebufferTexture2D( GLenum, GLenum, GLenum, GLuint, GLint )
    maxParam = 5;
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_ENUM_PARAM(2);
    READ_ENUM_PARAM(3);
    READ_PARAM(v32bit,4);
    TR.skipLine();
    CHECK_USER_CALL(glFramebufferTexture2D)
        UCT.glFramebufferTexture2D(param[0].uv32bit, param[1].uv32bit, param[2].uv32bit, param[3].uv32bit, param[4].v32bit);
    CHECK_GL_CALL(glFramebufferTexture2D)
        JT.glFramebufferTexture2D(param[0].uv32bit, param[1].uv32bit, param[2].uv32bit, param[3].uv32bit, param[4].v32bit);
}

void STUB_glFramebufferTexture2DEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glFramebufferTexture2DEXT( GLenum, GLenum, GLenum, GLuint, GLint )
    maxParam = 5;
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_ENUM_PARAM(2);
    READ_ENUM_PARAM(3);
    READ_PARAM(v32bit,4);
    TR.skipLine();
    CHECK_USER_CALL(glFramebufferTexture2DEXT)
        UCT.glFramebufferTexture2DEXT(param[0].uv32bit, param[1].uv32bit, param[2].uv32bit, param[3].uv32bit, param[4].v32bit);
    CHECK_GL_CALL(glFramebufferTexture2DEXT)
        JT.glFramebufferTexture2DEXT(param[0].uv32bit, param[1].uv32bit, param[2].uv32bit, param[3].uv32bit, param[4].v32bit);
}

void STUB_glFramebufferTexture3D( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glFramebufferTexture3D( GLenum, GLenum, GLenum, GLuint, GLint, GLint )
    maxParam = 6;
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_ENUM_PARAM(2);
    READ_ENUM_PARAM(3);
    READ_PARAM(v32bit,4);
    READ_PARAM(v32bit,5);
    TR.skipLine();
    CHECK_USER_CALL(glFramebufferTexture3D)
        UCT.glFramebufferTexture3D(param[0].uv32bit, param[1].uv32bit, param[2].uv32bit, param[3].uv32bit, param[4].v32bit, param[5].v32bit);
    CHECK_GL_CALL(glFramebufferTexture3D)
        JT.glFramebufferTexture3D(param[0].uv32bit, param[1].uv32bit, param[2].uv32bit, param[3].uv32bit, param[4].v32bit, param[5].v32bit);
}

void STUB_glFramebufferTexture3DEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glFramebufferTexture3DEXT( GLenum, GLenum, GLenum, GLuint, GLint, GLint )
    maxParam = 6;
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_ENUM_PARAM(2);
    READ_ENUM_PARAM(3);
    READ_PARAM(v32bit,4);
    READ_PARAM(v32bit,5);
    TR.skipLine();
    CHECK_USER_CALL(glFramebufferTexture3DEXT)
        UCT.glFramebufferTexture3DEXT(param[0].uv32bit, param[1].uv32bit, param[2].uv32bit, param[3].uv32bit, param[4].v32bit, param[5].v32bit);
    CHECK_GL_CALL(glFramebufferTexture3DEXT)
        JT.glFramebufferTexture3DEXT(param[0].uv32bit, param[1].uv32bit, param[2].uv32bit, param[3].uv32bit, param[4].v32bit, param[5].v32bit);
}

void STUB_glFramebufferTextureARB( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glFramebufferTextureARB( GLenum, GLenum, GLuint, GLint )
    maxParam = 4;
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_ENUM_PARAM(2);
    READ_PARAM(v32bit,3);
    TR.skipLine();
    CHECK_USER_CALL(glFramebufferTextureARB)
        UCT.glFramebufferTextureARB(param[0].uv32bit, param[1].uv32bit, param[2].uv32bit, param[3].v32bit);
    CHECK_GL_CALL(glFramebufferTextureARB)
        JT.glFramebufferTextureARB(param[0].uv32bit, param[1].uv32bit, param[2].uv32bit, param[3].v32bit);
}

void STUB_glFramebufferTextureEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glFramebufferTextureEXT( GLenum, GLenum, GLuint, GLint )
    maxParam = 4;
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_ENUM_PARAM(2);
    READ_PARAM(v32bit,3);
    TR.skipLine();
    CHECK_USER_CALL(glFramebufferTextureEXT)
        UCT.glFramebufferTextureEXT(param[0].uv32bit, param[1].uv32bit, param[2].uv32bit, param[3].v32bit);
    CHECK_GL_CALL(glFramebufferTextureEXT)
        JT.glFramebufferTextureEXT(param[0].uv32bit, param[1].uv32bit, param[2].uv32bit, param[3].v32bit);
}

void STUB_glFramebufferTextureFaceARB( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glFramebufferTextureFaceARB( GLenum, GLenum, GLuint, GLint, GLenum )
    maxParam = 5;
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_ENUM_PARAM(2);
    READ_PARAM(v32bit,3);
    READ_ENUM_PARAM(4);
    TR.skipLine();
    CHECK_USER_CALL(glFramebufferTextureFaceARB)
        UCT.glFramebufferTextureFaceARB(param[0].uv32bit, param[1].uv32bit, param[2].uv32bit, param[3].v32bit, param[4].uv32bit);
    CHECK_GL_CALL(glFramebufferTextureFaceARB)
        JT.glFramebufferTextureFaceARB(param[0].uv32bit, param[1].uv32bit, param[2].uv32bit, param[3].v32bit, param[4].uv32bit);
}

void STUB_glFramebufferTextureFaceEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glFramebufferTextureFaceEXT( GLenum, GLenum, GLuint, GLint, GLenum )
    maxParam = 5;
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_ENUM_PARAM(2);
    READ_PARAM(v32bit,3);
    READ_ENUM_PARAM(4);
    TR.skipLine();
    CHECK_USER_CALL(glFramebufferTextureFaceEXT)
        UCT.glFramebufferTextureFaceEXT(param[0].uv32bit, param[1].uv32bit, param[2].uv32bit, param[3].v32bit, param[4].uv32bit);
    CHECK_GL_CALL(glFramebufferTextureFaceEXT)
        JT.glFramebufferTextureFaceEXT(param[0].uv32bit, param[1].uv32bit, param[2].uv32bit, param[3].v32bit, param[4].uv32bit);
}

void STUB_glFramebufferTextureLayer( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glFramebufferTextureLayer( GLenum, GLenum, GLuint, GLint, GLint )
    maxParam = 5;
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_ENUM_PARAM(2);
    READ_PARAM(v32bit,3);
    READ_PARAM(v32bit,4);
    TR.skipLine();
    CHECK_USER_CALL(glFramebufferTextureLayer)
        UCT.glFramebufferTextureLayer(param[0].uv32bit, param[1].uv32bit, param[2].uv32bit, param[3].v32bit, param[4].v32bit);
    CHECK_GL_CALL(glFramebufferTextureLayer)
        JT.glFramebufferTextureLayer(param[0].uv32bit, param[1].uv32bit, param[2].uv32bit, param[3].v32bit, param[4].v32bit);
}

void STUB_glFramebufferTextureLayerARB( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glFramebufferTextureLayerARB( GLenum, GLenum, GLuint, GLint, GLint )
    maxParam = 5;
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_ENUM_PARAM(2);
    READ_PARAM(v32bit,3);
    READ_PARAM(v32bit,4);
    TR.skipLine();
    CHECK_USER_CALL(glFramebufferTextureLayerARB)
        UCT.glFramebufferTextureLayerARB(param[0].uv32bit, param[1].uv32bit, param[2].uv32bit, param[3].v32bit, param[4].v32bit);
    CHECK_GL_CALL(glFramebufferTextureLayerARB)
        JT.glFramebufferTextureLayerARB(param[0].uv32bit, param[1].uv32bit, param[2].uv32bit, param[3].v32bit, param[4].v32bit);
}

void STUB_glFramebufferTextureLayerEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glFramebufferTextureLayerEXT( GLenum, GLenum, GLuint, GLint, GLint )
    maxParam = 5;
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_ENUM_PARAM(2);
    READ_PARAM(v32bit,3);
    READ_PARAM(v32bit,4);
    TR.skipLine();
    CHECK_USER_CALL(glFramebufferTextureLayerEXT)
        UCT.glFramebufferTextureLayerEXT(param[0].uv32bit, param[1].uv32bit, param[2].uv32bit, param[3].v32bit, param[4].v32bit);
    CHECK_GL_CALL(glFramebufferTextureLayerEXT)
        JT.glFramebufferTextureLayerEXT(param[0].uv32bit, param[1].uv32bit, param[2].uv32bit, param[3].v32bit, param[4].v32bit);
}

void STUB_glFreeObjectBufferATI( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glFreeObjectBufferATI( GLuint )
    maxParam = 1;
    READ_ENUM_PARAM(0);
    TR.skipLine();
    CHECK_USER_CALL(glFreeObjectBufferATI)
        UCT.glFreeObjectBufferATI(param[0].uv32bit);
    CHECK_GL_CALL(glFreeObjectBufferATI)
        JT.glFreeObjectBufferATI(param[0].uv32bit);
}

void STUB_glFrontFace( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glFrontFace( GLenum mode )
    maxParam = 1;
    READ_ENUM_PARAM(0);
    TR.skipLine();
    CHECK_USER_CALL(glFrontFace)
        UCT.glFrontFace(param[0].uv32bit);
    CHECK_GL_CALL(glFrontFace)
        JT.glFrontFace(param[0].uv32bit);
}

void STUB_glFrustum( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glFrustum( GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble near_val, GLdouble far_val )
    maxParam = 6;
    READ_DOUBLE_PARAM(0);
    READ_DOUBLE_PARAM(1);
    READ_DOUBLE_PARAM(2);
    READ_DOUBLE_PARAM(3);
    READ_DOUBLE_PARAM(4);
    READ_DOUBLE_PARAM(5);
    TR.skipLine();
    CHECK_USER_CALL(glFrustum)
        UCT.glFrustum(param[0].fv64bit, param[1].fv64bit, param[2].fv64bit, param[3].fv64bit, param[4].fv64bit, param[5].fv64bit);
    CHECK_GL_CALL(glFrustum)
        JT.glFrustum(param[0].fv64bit, param[1].fv64bit, param[2].fv64bit, param[3].fv64bit, param[4].fv64bit, param[5].fv64bit);
}

void STUB_glGenAsyncMarkersSGIX( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // GLuint glGenAsyncMarkersSGIX( GLsizei )
    maxParam = 1;
    READ_PARAM(v32bit,0);
    TR.skipResult();
    TR.skipLine();
    CHECK_USER_CALL(glGenAsyncMarkersSGIX)
        UCT.glGenAsyncMarkersSGIX(param[0].v32bit);
    CHECK_GL_CALL(glGenAsyncMarkersSGIX)
        JT.glGenAsyncMarkersSGIX(param[0].v32bit);
}

void STUB_glGenBuffers( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glGenBuffers( GLsizei, GLuint * )
    maxParam = 2;
    char buffer0[16*4096];
    READ_PARAM(v32bit,0);
    READ_ARRAY_PARAM( 1, buffer0, TraceReader::TEXT_INT);
    TR.skipLine();
    CHECK_USER_CALL(glGenBuffers)
        UCT.glGenBuffers(param[0].v32bit, (GLuint *)param[1].ptr);
    CHECK_GL_CALL(glGenBuffers)
        JT.glGenBuffers(param[0].v32bit, (GLuint *)param[1].ptr);
}

void STUB_glGenBuffersARB( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glGenBuffersARB( GLsizei, GLuint * )
    maxParam = 2;
    char buffer0[16*4096];
    READ_PARAM(v32bit,0);
    READ_ARRAY_PARAM( 1, buffer0, TraceReader::TEXT_INT);
    TR.skipLine();
    CHECK_USER_CALL(glGenBuffersARB)
        UCT.glGenBuffersARB(param[0].v32bit, (GLuint *)param[1].ptr);
    CHECK_GL_CALL(glGenBuffersARB)
        JT.glGenBuffersARB(param[0].v32bit, (GLuint *)param[1].ptr);
}

void STUB_glGenFencesAPPLE( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glGenFencesAPPLE( GLsizei, GLuint * )
    maxParam = 2;
    char buffer0[16*4096];
    READ_PARAM(v32bit,0);
    READ_ARRAY_PARAM( 1, buffer0, TraceReader::TEXT_INT);
    TR.skipLine();
    CHECK_USER_CALL(glGenFencesAPPLE)
        UCT.glGenFencesAPPLE(param[0].v32bit, (GLuint *)param[1].ptr);
    CHECK_GL_CALL(glGenFencesAPPLE)
        JT.glGenFencesAPPLE(param[0].v32bit, (GLuint *)param[1].ptr);
}

void STUB_glGenFencesNV( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glGenFencesNV( GLsizei, GLuint * )
    maxParam = 2;
    char buffer0[16*4096];
    READ_PARAM(v32bit,0);
    READ_ARRAY_PARAM( 1, buffer0, TraceReader::TEXT_INT);
    TR.skipLine();
    CHECK_USER_CALL(glGenFencesNV)
        UCT.glGenFencesNV(param[0].v32bit, (GLuint *)param[1].ptr);
    CHECK_GL_CALL(glGenFencesNV)
        JT.glGenFencesNV(param[0].v32bit, (GLuint *)param[1].ptr);
}

void STUB_glGenFragmentShadersATI( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // GLuint glGenFragmentShadersATI( GLuint )
    maxParam = 1;
    READ_ENUM_PARAM(0);
    TR.skipResult();
    TR.skipLine();
    CHECK_USER_CALL(glGenFragmentShadersATI)
        UCT.glGenFragmentShadersATI(param[0].uv32bit);
    CHECK_GL_CALL(glGenFragmentShadersATI)
        JT.glGenFragmentShadersATI(param[0].uv32bit);
}

void STUB_glGenFramebuffers( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glGenFramebuffers( GLsizei, GLuint * )
    maxParam = 2;
    char buffer0[16*4096];
    READ_PARAM(v32bit,0);
    READ_ARRAY_PARAM( 1, buffer0, TraceReader::TEXT_INT);
    TR.skipLine();
    CHECK_USER_CALL(glGenFramebuffers)
        UCT.glGenFramebuffers(param[0].v32bit, (GLuint *)param[1].ptr);
    CHECK_GL_CALL(glGenFramebuffers)
        JT.glGenFramebuffers(param[0].v32bit, (GLuint *)param[1].ptr);
}

void STUB_glGenFramebuffersEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glGenFramebuffersEXT( GLsizei, GLuint * )
    maxParam = 2;
    char buffer0[16*4096];
    READ_PARAM(v32bit,0);
    READ_ARRAY_PARAM( 1, buffer0, TraceReader::TEXT_INT);
    TR.skipLine();
    CHECK_USER_CALL(glGenFramebuffersEXT)
        UCT.glGenFramebuffersEXT(param[0].v32bit, (GLuint *)param[1].ptr);
    CHECK_GL_CALL(glGenFramebuffersEXT)
        JT.glGenFramebuffersEXT(param[0].v32bit, (GLuint *)param[1].ptr);
}

void STUB_glGenLists( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // GLuint glGenLists( GLsizei range )
    maxParam = 1;
    READ_PARAM(v32bit,0);
    TR.skipResult();
    TR.skipLine();
    CHECK_USER_CALL(glGenLists)
        UCT.glGenLists(param[0].v32bit);
    CHECK_GL_CALL(glGenLists)
        JT.glGenLists(param[0].v32bit);
}

void STUB_glGenOcclusionQueriesNV( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glGenOcclusionQueriesNV( GLsizei, GLuint * )
    maxParam = 2;
    char buffer0[16*4096];
    READ_PARAM(v32bit,0);
    READ_ARRAY_PARAM( 1, buffer0, TraceReader::TEXT_INT);
    TR.skipLine();
    CHECK_USER_CALL(glGenOcclusionQueriesNV)
        UCT.glGenOcclusionQueriesNV(param[0].v32bit, (GLuint *)param[1].ptr);
    CHECK_GL_CALL(glGenOcclusionQueriesNV)
        JT.glGenOcclusionQueriesNV(param[0].v32bit, (GLuint *)param[1].ptr);
}

void STUB_glGenPerfMonitorsAMD( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glGenPerfMonitorsAMD( GLsizei, GLuint * )
    maxParam = 2;
    char buffer0[16*4096];
    READ_PARAM(v32bit,0);
    READ_ARRAY_PARAM( 1, buffer0, TraceReader::TEXT_INT);
    TR.skipLine();
    CHECK_USER_CALL(glGenPerfMonitorsAMD)
        UCT.glGenPerfMonitorsAMD(param[0].v32bit, (GLuint *)param[1].ptr);
    CHECK_GL_CALL(glGenPerfMonitorsAMD)
        JT.glGenPerfMonitorsAMD(param[0].v32bit, (GLuint *)param[1].ptr);
}

void STUB_glGenProgramsARB( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glGenProgramsARB( GLsizei, GLuint * )
    maxParam = 2;
    char buffer0[16*4096];
    READ_PARAM(v32bit,0);
    READ_ARRAY_PARAM( 1, buffer0, TraceReader::TEXT_INT);
    TR.skipLine();
    CHECK_USER_CALL(glGenProgramsARB)
        UCT.glGenProgramsARB(param[0].v32bit, (GLuint *)param[1].ptr);
    CHECK_GL_CALL(glGenProgramsARB)
        JT.glGenProgramsARB(param[0].v32bit, (GLuint *)param[1].ptr);
}

void STUB_glGenProgramsNV( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glGenProgramsNV( GLsizei, GLuint * )
    maxParam = 2;
    char buffer0[16*4096];
    READ_PARAM(v32bit,0);
    READ_ARRAY_PARAM( 1, buffer0, TraceReader::TEXT_INT);
    TR.skipLine();
    CHECK_USER_CALL(glGenProgramsNV)
        UCT.glGenProgramsNV(param[0].v32bit, (GLuint *)param[1].ptr);
    CHECK_GL_CALL(glGenProgramsNV)
        JT.glGenProgramsNV(param[0].v32bit, (GLuint *)param[1].ptr);
}

void STUB_glGenQueries( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glGenQueries( GLsizei, GLuint * )
    maxParam = 2;
    char buffer0[16*4096];
    READ_PARAM(v32bit,0);
    READ_ARRAY_PARAM( 1, buffer0, TraceReader::TEXT_INT);
    TR.skipLine();
    CHECK_USER_CALL(glGenQueries)
        UCT.glGenQueries(param[0].v32bit, (GLuint *)param[1].ptr);
    CHECK_GL_CALL(glGenQueries)
        JT.glGenQueries(param[0].v32bit, (GLuint *)param[1].ptr);
}

void STUB_glGenQueriesARB( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glGenQueriesARB( GLsizei, GLuint * )
    maxParam = 2;
    char buffer0[16*4096];
    READ_PARAM(v32bit,0);
    READ_ARRAY_PARAM( 1, buffer0, TraceReader::TEXT_INT);
    TR.skipLine();
    CHECK_USER_CALL(glGenQueriesARB)
        UCT.glGenQueriesARB(param[0].v32bit, (GLuint *)param[1].ptr);
    CHECK_GL_CALL(glGenQueriesARB)
        JT.glGenQueriesARB(param[0].v32bit, (GLuint *)param[1].ptr);
}

void STUB_glGenRenderbuffers( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glGenRenderbuffers( GLsizei, GLuint * )
    maxParam = 2;
    char buffer0[16*4096];
    READ_PARAM(v32bit,0);
    READ_ARRAY_PARAM( 1, buffer0, TraceReader::TEXT_INT);
    TR.skipLine();
    CHECK_USER_CALL(glGenRenderbuffers)
        UCT.glGenRenderbuffers(param[0].v32bit, (GLuint *)param[1].ptr);
    CHECK_GL_CALL(glGenRenderbuffers)
        JT.glGenRenderbuffers(param[0].v32bit, (GLuint *)param[1].ptr);
}

void STUB_glGenRenderbuffersEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glGenRenderbuffersEXT( GLsizei, GLuint * )
    maxParam = 2;
    char buffer0[16*4096];
    READ_PARAM(v32bit,0);
    READ_ARRAY_PARAM( 1, buffer0, TraceReader::TEXT_INT);
    TR.skipLine();
    CHECK_USER_CALL(glGenRenderbuffersEXT)
        UCT.glGenRenderbuffersEXT(param[0].v32bit, (GLuint *)param[1].ptr);
    CHECK_GL_CALL(glGenRenderbuffersEXT)
        JT.glGenRenderbuffersEXT(param[0].v32bit, (GLuint *)param[1].ptr);
}

void STUB_glGenSymbolsEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // GLuint glGenSymbolsEXT( GLenum, GLenum, GLenum, GLuint )
    maxParam = 4;
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_ENUM_PARAM(2);
    READ_ENUM_PARAM(3);
    TR.skipResult();
    TR.skipLine();
    CHECK_USER_CALL(glGenSymbolsEXT)
        UCT.glGenSymbolsEXT(param[0].uv32bit, param[1].uv32bit, param[2].uv32bit, param[3].uv32bit);
    CHECK_GL_CALL(glGenSymbolsEXT)
        JT.glGenSymbolsEXT(param[0].uv32bit, param[1].uv32bit, param[2].uv32bit, param[3].uv32bit);
}

void STUB_glGenTextures( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glGenTextures( GLsizei n, GLuint *textures )
    maxParam = 2;
    char buffer0[16*4096];
    READ_PARAM(v32bit,0);
    READ_ARRAY_PARAM( 1, buffer0, TraceReader::TEXT_INT);
    TR.skipLine();
    CHECK_USER_CALL(glGenTextures)
        UCT.glGenTextures(param[0].v32bit, (GLuint *)param[1].ptr);
    CHECK_GL_CALL(glGenTextures)
        JT.glGenTextures(param[0].v32bit, (GLuint *)param[1].ptr);
}

void STUB_glGenTexturesEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glGenTexturesEXT( GLsizei, GLuint * )
    maxParam = 2;
    char buffer0[16*4096];
    READ_PARAM(v32bit,0);
    READ_ARRAY_PARAM( 1, buffer0, TraceReader::TEXT_INT);
    TR.skipLine();
    CHECK_USER_CALL(glGenTexturesEXT)
        UCT.glGenTexturesEXT(param[0].v32bit, (GLuint *)param[1].ptr);
    CHECK_GL_CALL(glGenTexturesEXT)
        JT.glGenTexturesEXT(param[0].v32bit, (GLuint *)param[1].ptr);
}

void STUB_glGenTransformFeedbacksNV( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glGenTransformFeedbacksNV( GLsizei, GLuint * )
    maxParam = 2;
    char buffer0[16*4096];
    READ_PARAM(v32bit,0);
    READ_ARRAY_PARAM( 1, buffer0, TraceReader::TEXT_INT);
    TR.skipLine();
    CHECK_USER_CALL(glGenTransformFeedbacksNV)
        UCT.glGenTransformFeedbacksNV(param[0].v32bit, (GLuint *)param[1].ptr);
    CHECK_GL_CALL(glGenTransformFeedbacksNV)
        JT.glGenTransformFeedbacksNV(param[0].v32bit, (GLuint *)param[1].ptr);
}

void STUB_glGenVertexArrays( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glGenVertexArrays( GLsizei, GLuint * )
    maxParam = 2;
    char buffer0[16*4096];
    READ_PARAM(v32bit,0);
    READ_ARRAY_PARAM( 1, buffer0, TraceReader::TEXT_INT);
    TR.skipLine();
    CHECK_USER_CALL(glGenVertexArrays)
        UCT.glGenVertexArrays(param[0].v32bit, (GLuint *)param[1].ptr);
    CHECK_GL_CALL(glGenVertexArrays)
        JT.glGenVertexArrays(param[0].v32bit, (GLuint *)param[1].ptr);
}

void STUB_glGenVertexArraysAPPLE( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glGenVertexArraysAPPLE( GLsizei, GLuint * )
    maxParam = 2;
    char buffer0[16*4096];
    READ_PARAM(v32bit,0);
    READ_ARRAY_PARAM( 1, buffer0, TraceReader::TEXT_INT);
    TR.skipLine();
    CHECK_USER_CALL(glGenVertexArraysAPPLE)
        UCT.glGenVertexArraysAPPLE(param[0].v32bit, (GLuint *)param[1].ptr);
    CHECK_GL_CALL(glGenVertexArraysAPPLE)
        JT.glGenVertexArraysAPPLE(param[0].v32bit, (GLuint *)param[1].ptr);
}

void STUB_glGenVertexShadersEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // GLuint glGenVertexShadersEXT( GLuint )
    maxParam = 1;
    READ_ENUM_PARAM(0);
    TR.skipResult();
    TR.skipLine();
    CHECK_USER_CALL(glGenVertexShadersEXT)
        UCT.glGenVertexShadersEXT(param[0].uv32bit);
    CHECK_GL_CALL(glGenVertexShadersEXT)
        JT.glGenVertexShadersEXT(param[0].uv32bit);
}

void STUB_glGenerateMipmap( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glGenerateMipmap( GLenum )
    maxParam = 1;
    READ_ENUM_PARAM(0);
    TR.skipLine();
    CHECK_USER_CALL(glGenerateMipmap)
        UCT.glGenerateMipmap(param[0].uv32bit);
    CHECK_GL_CALL(glGenerateMipmap)
        JT.glGenerateMipmap(param[0].uv32bit);
}

void STUB_glGenerateMipmapEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glGenerateMipmapEXT( GLenum )
    maxParam = 1;
    READ_ENUM_PARAM(0);
    TR.skipLine();
    CHECK_USER_CALL(glGenerateMipmapEXT)
        UCT.glGenerateMipmapEXT(param[0].uv32bit);
    CHECK_GL_CALL(glGenerateMipmapEXT)
        JT.glGenerateMipmapEXT(param[0].uv32bit);
}

void STUB_glGenerateMultiTexMipmapEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glGenerateMultiTexMipmapEXT( GLenum, GLenum )
    maxParam = 2;
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    TR.skipLine();
    CHECK_USER_CALL(glGenerateMultiTexMipmapEXT)
        UCT.glGenerateMultiTexMipmapEXT(param[0].uv32bit, param[1].uv32bit);
    CHECK_GL_CALL(glGenerateMultiTexMipmapEXT)
        JT.glGenerateMultiTexMipmapEXT(param[0].uv32bit, param[1].uv32bit);
}

void STUB_glGenerateTextureMipmapEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glGenerateTextureMipmapEXT( GLuint, GLenum )
    maxParam = 2;
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    TR.skipLine();
    CHECK_USER_CALL(glGenerateTextureMipmapEXT)
        UCT.glGenerateTextureMipmapEXT(param[0].uv32bit, param[1].uv32bit);
    CHECK_GL_CALL(glGenerateTextureMipmapEXT)
        JT.glGenerateTextureMipmapEXT(param[0].uv32bit, param[1].uv32bit);
}

void STUB_glGetActiveAttrib( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glGetActiveAttrib( GLuint, GLuint, GLsizei, GLsizei *, GLint *, GLenum *, GLchar * )
    // Call not playable
    TR.skipCall();
}

void STUB_glGetActiveAttribARB( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glGetActiveAttribARB( GLhandleARB, GLuint, GLsizei, GLsizei *, GLint *, GLenum *, GLcharARB * )
    maxParam = 7;
    char buffer0[16*4096];
    char buffer1[16*4096];
    char buffer2[16*4096];
    char buffer3[16*4096];
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_PARAM(v32bit,2);
    READ_ARRAY_PARAM( 3, buffer0, TraceReader::TEXT_INT);
    READ_ARRAY_PARAM( 4, buffer1, TraceReader::TEXT_INT);
    READ_ARRAY_PARAM( 5, buffer2, TraceReader::TEXT_INT);
    READ_ARRAY_PARAM( 6, buffer3, TraceReader::TEXT_BYTE);
    TR.skipLine();
    CHECK_USER_CALL(glGetActiveAttribARB)
        UCT.glGetActiveAttribARB(param[0].uv32bit, param[1].uv32bit, param[2].v32bit, (GLsizei *)param[3].ptr, (GLint *)param[4].ptr, (GLenum *)param[5].ptr, (GLcharARB *)param[6].ptr);
    CHECK_GL_CALL(glGetActiveAttribARB)
        JT.glGetActiveAttribARB(param[0].uv32bit, param[1].uv32bit, param[2].v32bit, (GLsizei *)param[3].ptr, (GLint *)param[4].ptr, (GLenum *)param[5].ptr, (GLcharARB *)param[6].ptr);
}

void STUB_glGetActiveUniform( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glGetActiveUniform( GLuint, GLuint, GLsizei, GLsizei *, GLint *, GLenum *, GLchar * )
    // Call not playable
    TR.skipCall();
}

void STUB_glGetActiveUniformARB( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glGetActiveUniformARB( GLhandleARB, GLuint, GLsizei, GLsizei *, GLint *, GLenum *, GLcharARB * )
    maxParam = 7;
    char buffer0[16*4096];
    char buffer1[16*4096];
    char buffer2[16*4096];
    char buffer3[16*4096];
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_PARAM(v32bit,2);
    READ_ARRAY_PARAM( 3, buffer0, TraceReader::TEXT_INT);
    READ_ARRAY_PARAM( 4, buffer1, TraceReader::TEXT_INT);
    READ_ARRAY_PARAM( 5, buffer2, TraceReader::TEXT_INT);
    READ_ARRAY_PARAM( 6, buffer3, TraceReader::TEXT_BYTE);
    TR.skipLine();
    CHECK_USER_CALL(glGetActiveUniformARB)
        UCT.glGetActiveUniformARB(param[0].uv32bit, param[1].uv32bit, param[2].v32bit, (GLsizei *)param[3].ptr, (GLint *)param[4].ptr, (GLenum *)param[5].ptr, (GLcharARB *)param[6].ptr);
    CHECK_GL_CALL(glGetActiveUniformARB)
        JT.glGetActiveUniformARB(param[0].uv32bit, param[1].uv32bit, param[2].v32bit, (GLsizei *)param[3].ptr, (GLint *)param[4].ptr, (GLenum *)param[5].ptr, (GLcharARB *)param[6].ptr);
}

void STUB_glGetActiveUniformBlockName( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glGetActiveUniformBlockName( GLuint, GLuint, GLsizei, GLsizei *, GLchar * )
    // Call not playable
    TR.skipCall();
}

void STUB_glGetActiveUniformBlockiv( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glGetActiveUniformBlockiv( GLuint, GLuint, GLenum, GLint * )
    maxParam = 4;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_ENUM_PARAM(2);
    READ_ARRAY_PARAM( 3, buffer0, TraceReader::TEXT_INT);
    TR.skipLine();
    CHECK_USER_CALL(glGetActiveUniformBlockiv)
        UCT.glGetActiveUniformBlockiv(param[0].uv32bit, param[1].uv32bit, param[2].uv32bit, (GLint *)param[3].ptr);
    CHECK_GL_CALL(glGetActiveUniformBlockiv)
        JT.glGetActiveUniformBlockiv(param[0].uv32bit, param[1].uv32bit, param[2].uv32bit, (GLint *)param[3].ptr);
}

void STUB_glGetActiveUniformName( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glGetActiveUniformName( GLuint, GLuint, GLsizei, GLsizei *, GLchar * )
    // Call not playable
    TR.skipCall();
}

void STUB_glGetActiveUniformsiv( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glGetActiveUniformsiv( GLuint, GLsizei, const GLuint *, GLenum, GLint * )
    maxParam = 5;
    char buffer0[16*4096];
    char buffer1[16*4096];
    READ_ENUM_PARAM(0);
    READ_PARAM(v32bit,1);
    READ_ARRAY_PARAM( 2, buffer0, TraceReader::TEXT_INT);
    READ_ENUM_PARAM(3);
    READ_ARRAY_PARAM( 4, buffer1, TraceReader::TEXT_INT);
    TR.skipLine();
    CHECK_USER_CALL(glGetActiveUniformsiv)
        UCT.glGetActiveUniformsiv(param[0].uv32bit, param[1].v32bit, (const GLuint *)param[2].ptr, param[3].uv32bit, (GLint *)param[4].ptr);
    CHECK_GL_CALL(glGetActiveUniformsiv)
        JT.glGetActiveUniformsiv(param[0].uv32bit, param[1].v32bit, (const GLuint *)param[2].ptr, param[3].uv32bit, (GLint *)param[4].ptr);
}

void STUB_glGetActiveVaryingNV( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glGetActiveVaryingNV( GLuint, GLuint, GLsizei, GLsizei *, GLsizei *, GLenum *, GLchar * )
    // Call not playable
    TR.skipCall();
}

void STUB_glGetArrayObjectfvATI( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glGetArrayObjectfvATI( GLenum, GLenum, GLfloat * )
    maxParam = 3;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_ARRAY_PARAM( 2, buffer0, TraceReader::TEXT_FLOAT);
    TR.skipLine();
    CHECK_USER_CALL(glGetArrayObjectfvATI)
        UCT.glGetArrayObjectfvATI(param[0].uv32bit, param[1].uv32bit, (GLfloat *)param[2].ptr);
    CHECK_GL_CALL(glGetArrayObjectfvATI)
        JT.glGetArrayObjectfvATI(param[0].uv32bit, param[1].uv32bit, (GLfloat *)param[2].ptr);
}

void STUB_glGetArrayObjectivATI( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glGetArrayObjectivATI( GLenum, GLenum, GLint * )
    maxParam = 3;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_ARRAY_PARAM( 2, buffer0, TraceReader::TEXT_INT);
    TR.skipLine();
    CHECK_USER_CALL(glGetArrayObjectivATI)
        UCT.glGetArrayObjectivATI(param[0].uv32bit, param[1].uv32bit, (GLint *)param[2].ptr);
    CHECK_GL_CALL(glGetArrayObjectivATI)
        JT.glGetArrayObjectivATI(param[0].uv32bit, param[1].uv32bit, (GLint *)param[2].ptr);
}

void STUB_glGetAttachedObjectsARB( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glGetAttachedObjectsARB( GLhandleARB, GLsizei, GLsizei *, GLhandleARB * )
    maxParam = 4;
    char buffer0[16*4096];
    char buffer1[16*4096];
    READ_ENUM_PARAM(0);
    READ_PARAM(v32bit,1);
    READ_ARRAY_PARAM( 2, buffer0, TraceReader::TEXT_INT);
    READ_ARRAY_PARAM( 3, buffer1, TraceReader::TEXT_INT);
    TR.skipLine();
    CHECK_USER_CALL(glGetAttachedObjectsARB)
        UCT.glGetAttachedObjectsARB(param[0].uv32bit, param[1].v32bit, (GLsizei *)param[2].ptr, (GLhandleARB *)param[3].ptr);
    CHECK_GL_CALL(glGetAttachedObjectsARB)
        JT.glGetAttachedObjectsARB(param[0].uv32bit, param[1].v32bit, (GLsizei *)param[2].ptr, (GLhandleARB *)param[3].ptr);
}

void STUB_glGetAttachedShaders( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glGetAttachedShaders( GLuint, GLsizei, GLsizei *, GLuint * )
    maxParam = 4;
    char buffer0[16*4096];
    char buffer1[16*4096];
    READ_ENUM_PARAM(0);
    READ_PARAM(v32bit,1);
    READ_ARRAY_PARAM( 2, buffer0, TraceReader::TEXT_INT);
    READ_ARRAY_PARAM( 3, buffer1, TraceReader::TEXT_INT);
    TR.skipLine();
    CHECK_USER_CALL(glGetAttachedShaders)
        UCT.glGetAttachedShaders(param[0].uv32bit, param[1].v32bit, (GLsizei *)param[2].ptr, (GLuint *)param[3].ptr);
    CHECK_GL_CALL(glGetAttachedShaders)
        JT.glGetAttachedShaders(param[0].uv32bit, param[1].v32bit, (GLsizei *)param[2].ptr, (GLuint *)param[3].ptr);
}

void STUB_glGetAttribLocation( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // GLint glGetAttribLocation( GLuint, const GLchar * )
    // Call not playable
    TR.skipCall();
}

void STUB_glGetAttribLocationARB( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // GLint glGetAttribLocationARB( GLhandleARB, const GLcharARB * )
    maxParam = 2;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ARRAY_PARAM( 1, buffer0, TraceReader::TEXT_BYTE);
    TR.skipResult();
    TR.skipLine();
    CHECK_USER_CALL(glGetAttribLocationARB)
        UCT.glGetAttribLocationARB(param[0].uv32bit, (const GLcharARB *)param[1].ptr);
    CHECK_GL_CALL(glGetAttribLocationARB)
        JT.glGetAttribLocationARB(param[0].uv32bit, (const GLcharARB *)param[1].ptr);
}

void STUB_glGetBooleanIndexedvEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glGetBooleanIndexedvEXT( GLenum, GLuint, GLboolean * )
    maxParam = 3;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_ARRAY_PARAM( 2, buffer0, TraceReader::TEXT_BYTE);
    TR.skipLine();
    CHECK_USER_CALL(glGetBooleanIndexedvEXT)
        UCT.glGetBooleanIndexedvEXT(param[0].uv32bit, param[1].uv32bit, (GLboolean *)param[2].ptr);
    CHECK_GL_CALL(glGetBooleanIndexedvEXT)
        JT.glGetBooleanIndexedvEXT(param[0].uv32bit, param[1].uv32bit, (GLboolean *)param[2].ptr);
}

void STUB_glGetBooleani_v( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glGetBooleani_v( GLenum, GLuint, GLboolean * )
    maxParam = 3;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_ARRAY_PARAM( 2, buffer0, TraceReader::TEXT_BYTE);
    TR.skipLine();
    CHECK_USER_CALL(glGetBooleani_v)
        UCT.glGetBooleani_v(param[0].uv32bit, param[1].uv32bit, (GLboolean *)param[2].ptr);
    CHECK_GL_CALL(glGetBooleani_v)
        JT.glGetBooleani_v(param[0].uv32bit, param[1].uv32bit, (GLboolean *)param[2].ptr);
}

void STUB_glGetBooleanv( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glGetBooleanv( GLenum pname, GLboolean *params )
    maxParam = 2;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ARRAY_PARAM( 1, buffer0, TraceReader::TEXT_BYTE);
    TR.skipLine();
    CHECK_USER_CALL(glGetBooleanv)
        UCT.glGetBooleanv(param[0].uv32bit, (GLboolean *)param[1].ptr);
    CHECK_GL_CALL(glGetBooleanv)
        JT.glGetBooleanv(param[0].uv32bit, (GLboolean *)param[1].ptr);
}

void STUB_glGetBufferParameteriv( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glGetBufferParameteriv( GLenum, GLenum, GLint * )
    maxParam = 3;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_ARRAY_PARAM( 2, buffer0, TraceReader::TEXT_INT);
    TR.skipLine();
    CHECK_USER_CALL(glGetBufferParameteriv)
        UCT.glGetBufferParameteriv(param[0].uv32bit, param[1].uv32bit, (GLint *)param[2].ptr);
    CHECK_GL_CALL(glGetBufferParameteriv)
        JT.glGetBufferParameteriv(param[0].uv32bit, param[1].uv32bit, (GLint *)param[2].ptr);
}

void STUB_glGetBufferParameterivARB( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glGetBufferParameterivARB( GLenum, GLenum, GLint * )
    maxParam = 3;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_ARRAY_PARAM( 2, buffer0, TraceReader::TEXT_INT);
    TR.skipLine();
    CHECK_USER_CALL(glGetBufferParameterivARB)
        UCT.glGetBufferParameterivARB(param[0].uv32bit, param[1].uv32bit, (GLint *)param[2].ptr);
    CHECK_GL_CALL(glGetBufferParameterivARB)
        JT.glGetBufferParameterivARB(param[0].uv32bit, param[1].uv32bit, (GLint *)param[2].ptr);
}

void STUB_glGetBufferPointerv( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glGetBufferPointerv( GLenum, GLenum, GLvoid ** )
    maxParam = 3;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_ARRAY_PARAM( 2, buffer0, TraceReader::TEXT_IGNORE);
    TR.skipLine();
    CHECK_USER_CALL(glGetBufferPointerv)
        UCT.glGetBufferPointerv(param[0].uv32bit, param[1].uv32bit, (GLvoid **)param[2].ptr);
    CHECK_GL_CALL(glGetBufferPointerv)
        JT.glGetBufferPointerv(param[0].uv32bit, param[1].uv32bit, (GLvoid **)param[2].ptr);
}

void STUB_glGetBufferPointervARB( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glGetBufferPointervARB( GLenum, GLenum, GLvoid ** )
    maxParam = 3;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_ARRAY_PARAM( 2, buffer0, TraceReader::TEXT_IGNORE);
    TR.skipLine();
    CHECK_USER_CALL(glGetBufferPointervARB)
        UCT.glGetBufferPointervARB(param[0].uv32bit, param[1].uv32bit, (GLvoid **)param[2].ptr);
    CHECK_GL_CALL(glGetBufferPointervARB)
        JT.glGetBufferPointervARB(param[0].uv32bit, param[1].uv32bit, (GLvoid **)param[2].ptr);
}

void STUB_glGetBufferSubData( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glGetBufferSubData( GLenum, GLintptr, GLsizeiptr, GLvoid * )
    maxParam = 4;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_PARAM(v32bit,1);
    READ_PARAM(v32bit,2);
    READ_ARRAY_PARAM( 3, buffer0, TraceReader::TEXT_IGNORE);
    TR.skipLine();
    CHECK_USER_CALL(glGetBufferSubData)
        UCT.glGetBufferSubData(param[0].uv32bit, param[1].v32bit, param[2].v32bit, (GLvoid *)param[3].ptr);
    CHECK_GL_CALL(glGetBufferSubData)
        JT.glGetBufferSubData(param[0].uv32bit, param[1].v32bit, param[2].v32bit, (GLvoid *)param[3].ptr);
}

void STUB_glGetBufferSubDataARB( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glGetBufferSubDataARB( GLenum, GLintptrARB, GLsizeiptrARB, GLvoid * )
    maxParam = 4;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_PARAM(v32bit,1);
    READ_PARAM(v32bit,2);
    READ_ARRAY_PARAM( 3, buffer0, TraceReader::TEXT_IGNORE);
    TR.skipLine();
    CHECK_USER_CALL(glGetBufferSubDataARB)
        UCT.glGetBufferSubDataARB(param[0].uv32bit, param[1].v32bit, param[2].v32bit, (GLvoid *)param[3].ptr);
    CHECK_GL_CALL(glGetBufferSubDataARB)
        JT.glGetBufferSubDataARB(param[0].uv32bit, param[1].v32bit, param[2].v32bit, (GLvoid *)param[3].ptr);
}

void STUB_glGetClipPlane( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glGetClipPlane( GLenum plane, GLdouble *equation )
    maxParam = 2;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ARRAY_PARAM( 1, buffer0, TraceReader::TEXT_DOUBLE);
    TR.skipLine();
    CHECK_USER_CALL(glGetClipPlane)
        UCT.glGetClipPlane(param[0].uv32bit, (GLdouble *)param[1].ptr);
    CHECK_GL_CALL(glGetClipPlane)
        JT.glGetClipPlane(param[0].uv32bit, (GLdouble *)param[1].ptr);
}

void STUB_glGetColorTable( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glGetColorTable( GLenum target, GLenum format, GLenum type, GLvoid *table )
    maxParam = 4;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_ENUM_PARAM(2);
    READ_ARRAY_PARAM( 3, buffer0, TraceReader::TEXT_IGNORE);
    TR.skipLine();
    CHECK_USER_CALL(glGetColorTable)
        UCT.glGetColorTable(param[0].uv32bit, param[1].uv32bit, param[2].uv32bit, (GLvoid *)param[3].ptr);
    CHECK_GL_CALL(glGetColorTable)
        JT.glGetColorTable(param[0].uv32bit, param[1].uv32bit, param[2].uv32bit, (GLvoid *)param[3].ptr);
}

void STUB_glGetColorTableEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glGetColorTableEXT( GLenum, GLenum, GLenum, GLvoid * )
    maxParam = 4;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_ENUM_PARAM(2);
    READ_ARRAY_PARAM( 3, buffer0, TraceReader::TEXT_IGNORE);
    TR.skipLine();
    CHECK_USER_CALL(glGetColorTableEXT)
        UCT.glGetColorTableEXT(param[0].uv32bit, param[1].uv32bit, param[2].uv32bit, (GLvoid *)param[3].ptr);
    CHECK_GL_CALL(glGetColorTableEXT)
        JT.glGetColorTableEXT(param[0].uv32bit, param[1].uv32bit, param[2].uv32bit, (GLvoid *)param[3].ptr);
}

void STUB_glGetColorTableParameterfv( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glGetColorTableParameterfv( GLenum target, GLenum pname, GLfloat *params )
    maxParam = 3;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_ARRAY_PARAM( 2, buffer0, TraceReader::TEXT_FLOAT);
    TR.skipLine();
    CHECK_USER_CALL(glGetColorTableParameterfv)
        UCT.glGetColorTableParameterfv(param[0].uv32bit, param[1].uv32bit, (GLfloat *)param[2].ptr);
    CHECK_GL_CALL(glGetColorTableParameterfv)
        JT.glGetColorTableParameterfv(param[0].uv32bit, param[1].uv32bit, (GLfloat *)param[2].ptr);
}

void STUB_glGetColorTableParameterfvEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glGetColorTableParameterfvEXT( GLenum, GLenum, GLfloat * )
    maxParam = 3;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_ARRAY_PARAM( 2, buffer0, TraceReader::TEXT_FLOAT);
    TR.skipLine();
    CHECK_USER_CALL(glGetColorTableParameterfvEXT)
        UCT.glGetColorTableParameterfvEXT(param[0].uv32bit, param[1].uv32bit, (GLfloat *)param[2].ptr);
    CHECK_GL_CALL(glGetColorTableParameterfvEXT)
        JT.glGetColorTableParameterfvEXT(param[0].uv32bit, param[1].uv32bit, (GLfloat *)param[2].ptr);
}

void STUB_glGetColorTableParameterfvSGI( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glGetColorTableParameterfvSGI( GLenum, GLenum, GLfloat * )
    maxParam = 3;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_ARRAY_PARAM( 2, buffer0, TraceReader::TEXT_FLOAT);
    TR.skipLine();
    CHECK_USER_CALL(glGetColorTableParameterfvSGI)
        UCT.glGetColorTableParameterfvSGI(param[0].uv32bit, param[1].uv32bit, (GLfloat *)param[2].ptr);
    CHECK_GL_CALL(glGetColorTableParameterfvSGI)
        JT.glGetColorTableParameterfvSGI(param[0].uv32bit, param[1].uv32bit, (GLfloat *)param[2].ptr);
}

void STUB_glGetColorTableParameteriv( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glGetColorTableParameteriv( GLenum target, GLenum pname, GLint *params )
    maxParam = 3;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_ARRAY_PARAM( 2, buffer0, TraceReader::TEXT_INT);
    TR.skipLine();
    CHECK_USER_CALL(glGetColorTableParameteriv)
        UCT.glGetColorTableParameteriv(param[0].uv32bit, param[1].uv32bit, (GLint *)param[2].ptr);
    CHECK_GL_CALL(glGetColorTableParameteriv)
        JT.glGetColorTableParameteriv(param[0].uv32bit, param[1].uv32bit, (GLint *)param[2].ptr);
}

void STUB_glGetColorTableParameterivEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glGetColorTableParameterivEXT( GLenum, GLenum, GLint * )
    maxParam = 3;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_ARRAY_PARAM( 2, buffer0, TraceReader::TEXT_INT);
    TR.skipLine();
    CHECK_USER_CALL(glGetColorTableParameterivEXT)
        UCT.glGetColorTableParameterivEXT(param[0].uv32bit, param[1].uv32bit, (GLint *)param[2].ptr);
    CHECK_GL_CALL(glGetColorTableParameterivEXT)
        JT.glGetColorTableParameterivEXT(param[0].uv32bit, param[1].uv32bit, (GLint *)param[2].ptr);
}

void STUB_glGetColorTableParameterivSGI( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glGetColorTableParameterivSGI( GLenum, GLenum, GLint * )
    maxParam = 3;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_ARRAY_PARAM( 2, buffer0, TraceReader::TEXT_INT);
    TR.skipLine();
    CHECK_USER_CALL(glGetColorTableParameterivSGI)
        UCT.glGetColorTableParameterivSGI(param[0].uv32bit, param[1].uv32bit, (GLint *)param[2].ptr);
    CHECK_GL_CALL(glGetColorTableParameterivSGI)
        JT.glGetColorTableParameterivSGI(param[0].uv32bit, param[1].uv32bit, (GLint *)param[2].ptr);
}

void STUB_glGetColorTableSGI( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glGetColorTableSGI( GLenum, GLenum, GLenum, GLvoid * )
    maxParam = 4;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_ENUM_PARAM(2);
    READ_ARRAY_PARAM( 3, buffer0, TraceReader::TEXT_IGNORE);
    TR.skipLine();
    CHECK_USER_CALL(glGetColorTableSGI)
        UCT.glGetColorTableSGI(param[0].uv32bit, param[1].uv32bit, param[2].uv32bit, (GLvoid *)param[3].ptr);
    CHECK_GL_CALL(glGetColorTableSGI)
        JT.glGetColorTableSGI(param[0].uv32bit, param[1].uv32bit, param[2].uv32bit, (GLvoid *)param[3].ptr);
}

void STUB_glGetCombinerInputParameterfvNV( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glGetCombinerInputParameterfvNV( GLenum, GLenum, GLenum, GLenum, GLfloat * )
    maxParam = 5;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_ENUM_PARAM(2);
    READ_ENUM_PARAM(3);
    READ_ARRAY_PARAM( 4, buffer0, TraceReader::TEXT_FLOAT);
    TR.skipLine();
    CHECK_USER_CALL(glGetCombinerInputParameterfvNV)
        UCT.glGetCombinerInputParameterfvNV(param[0].uv32bit, param[1].uv32bit, param[2].uv32bit, param[3].uv32bit, (GLfloat *)param[4].ptr);
    CHECK_GL_CALL(glGetCombinerInputParameterfvNV)
        JT.glGetCombinerInputParameterfvNV(param[0].uv32bit, param[1].uv32bit, param[2].uv32bit, param[3].uv32bit, (GLfloat *)param[4].ptr);
}

void STUB_glGetCombinerInputParameterivNV( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glGetCombinerInputParameterivNV( GLenum, GLenum, GLenum, GLenum, GLint * )
    maxParam = 5;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_ENUM_PARAM(2);
    READ_ENUM_PARAM(3);
    READ_ARRAY_PARAM( 4, buffer0, TraceReader::TEXT_INT);
    TR.skipLine();
    CHECK_USER_CALL(glGetCombinerInputParameterivNV)
        UCT.glGetCombinerInputParameterivNV(param[0].uv32bit, param[1].uv32bit, param[2].uv32bit, param[3].uv32bit, (GLint *)param[4].ptr);
    CHECK_GL_CALL(glGetCombinerInputParameterivNV)
        JT.glGetCombinerInputParameterivNV(param[0].uv32bit, param[1].uv32bit, param[2].uv32bit, param[3].uv32bit, (GLint *)param[4].ptr);
}

void STUB_glGetCombinerOutputParameterfvNV( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glGetCombinerOutputParameterfvNV( GLenum, GLenum, GLenum, GLfloat * )
    maxParam = 4;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_ENUM_PARAM(2);
    READ_ARRAY_PARAM( 3, buffer0, TraceReader::TEXT_FLOAT);
    TR.skipLine();
    CHECK_USER_CALL(glGetCombinerOutputParameterfvNV)
        UCT.glGetCombinerOutputParameterfvNV(param[0].uv32bit, param[1].uv32bit, param[2].uv32bit, (GLfloat *)param[3].ptr);
    CHECK_GL_CALL(glGetCombinerOutputParameterfvNV)
        JT.glGetCombinerOutputParameterfvNV(param[0].uv32bit, param[1].uv32bit, param[2].uv32bit, (GLfloat *)param[3].ptr);
}

void STUB_glGetCombinerOutputParameterivNV( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glGetCombinerOutputParameterivNV( GLenum, GLenum, GLenum, GLint * )
    maxParam = 4;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_ENUM_PARAM(2);
    READ_ARRAY_PARAM( 3, buffer0, TraceReader::TEXT_INT);
    TR.skipLine();
    CHECK_USER_CALL(glGetCombinerOutputParameterivNV)
        UCT.glGetCombinerOutputParameterivNV(param[0].uv32bit, param[1].uv32bit, param[2].uv32bit, (GLint *)param[3].ptr);
    CHECK_GL_CALL(glGetCombinerOutputParameterivNV)
        JT.glGetCombinerOutputParameterivNV(param[0].uv32bit, param[1].uv32bit, param[2].uv32bit, (GLint *)param[3].ptr);
}

void STUB_glGetCombinerStageParameterfvNV( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glGetCombinerStageParameterfvNV( GLenum, GLenum, GLfloat * )
    maxParam = 3;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_ARRAY_PARAM( 2, buffer0, TraceReader::TEXT_FLOAT);
    TR.skipLine();
    CHECK_USER_CALL(glGetCombinerStageParameterfvNV)
        UCT.glGetCombinerStageParameterfvNV(param[0].uv32bit, param[1].uv32bit, (GLfloat *)param[2].ptr);
    CHECK_GL_CALL(glGetCombinerStageParameterfvNV)
        JT.glGetCombinerStageParameterfvNV(param[0].uv32bit, param[1].uv32bit, (GLfloat *)param[2].ptr);
}

void STUB_glGetCompressedMultiTexImageEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glGetCompressedMultiTexImageEXT( GLenum, GLenum, GLint, GLvoid * )
    maxParam = 4;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_PARAM(v32bit,2);
    READ_ARRAY_PARAM( 3, buffer0, TraceReader::TEXT_IGNORE);
    TR.skipLine();
    CHECK_USER_CALL(glGetCompressedMultiTexImageEXT)
        UCT.glGetCompressedMultiTexImageEXT(param[0].uv32bit, param[1].uv32bit, param[2].v32bit, (GLvoid *)param[3].ptr);
    CHECK_GL_CALL(glGetCompressedMultiTexImageEXT)
        JT.glGetCompressedMultiTexImageEXT(param[0].uv32bit, param[1].uv32bit, param[2].v32bit, (GLvoid *)param[3].ptr);
}

void STUB_glGetCompressedTexImage( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glGetCompressedTexImage( GLenum target, GLint lod, GLvoid *img )
    maxParam = 3;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_PARAM(v32bit,1);
    READ_ARRAY_PARAM( 2, buffer0, TraceReader::TEXT_IGNORE);
    TR.skipLine();
    CHECK_USER_CALL(glGetCompressedTexImage)
        UCT.glGetCompressedTexImage(param[0].uv32bit, param[1].v32bit, (GLvoid *)param[2].ptr);
    CHECK_GL_CALL(glGetCompressedTexImage)
        JT.glGetCompressedTexImage(param[0].uv32bit, param[1].v32bit, (GLvoid *)param[2].ptr);
}

void STUB_glGetCompressedTexImageARB( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glGetCompressedTexImageARB( GLenum, GLint, GLvoid * )
    maxParam = 3;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_PARAM(v32bit,1);
    READ_ARRAY_PARAM( 2, buffer0, TraceReader::TEXT_IGNORE);
    TR.skipLine();
    CHECK_USER_CALL(glGetCompressedTexImageARB)
        UCT.glGetCompressedTexImageARB(param[0].uv32bit, param[1].v32bit, (GLvoid *)param[2].ptr);
    CHECK_GL_CALL(glGetCompressedTexImageARB)
        JT.glGetCompressedTexImageARB(param[0].uv32bit, param[1].v32bit, (GLvoid *)param[2].ptr);
}

void STUB_glGetCompressedTextureImageEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glGetCompressedTextureImageEXT( GLuint, GLenum, GLint, GLvoid * )
    maxParam = 4;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_PARAM(v32bit,2);
    READ_ARRAY_PARAM( 3, buffer0, TraceReader::TEXT_IGNORE);
    TR.skipLine();
    CHECK_USER_CALL(glGetCompressedTextureImageEXT)
        UCT.glGetCompressedTextureImageEXT(param[0].uv32bit, param[1].uv32bit, param[2].v32bit, (GLvoid *)param[3].ptr);
    CHECK_GL_CALL(glGetCompressedTextureImageEXT)
        JT.glGetCompressedTextureImageEXT(param[0].uv32bit, param[1].uv32bit, param[2].v32bit, (GLvoid *)param[3].ptr);
}

void STUB_glGetConvolutionFilter( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glGetConvolutionFilter( GLenum target, GLenum format, GLenum type, GLvoid *image )
    maxParam = 4;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_ENUM_PARAM(2);
    READ_ARRAY_PARAM( 3, buffer0, TraceReader::TEXT_IGNORE);
    TR.skipLine();
    CHECK_USER_CALL(glGetConvolutionFilter)
        UCT.glGetConvolutionFilter(param[0].uv32bit, param[1].uv32bit, param[2].uv32bit, (GLvoid *)param[3].ptr);
    CHECK_GL_CALL(glGetConvolutionFilter)
        JT.glGetConvolutionFilter(param[0].uv32bit, param[1].uv32bit, param[2].uv32bit, (GLvoid *)param[3].ptr);
}

void STUB_glGetConvolutionFilterEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glGetConvolutionFilterEXT( GLenum, GLenum, GLenum, GLvoid * )
    maxParam = 4;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_ENUM_PARAM(2);
    READ_ARRAY_PARAM( 3, buffer0, TraceReader::TEXT_IGNORE);
    TR.skipLine();
    CHECK_USER_CALL(glGetConvolutionFilterEXT)
        UCT.glGetConvolutionFilterEXT(param[0].uv32bit, param[1].uv32bit, param[2].uv32bit, (GLvoid *)param[3].ptr);
    CHECK_GL_CALL(glGetConvolutionFilterEXT)
        JT.glGetConvolutionFilterEXT(param[0].uv32bit, param[1].uv32bit, param[2].uv32bit, (GLvoid *)param[3].ptr);
}

void STUB_glGetConvolutionParameterfv( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glGetConvolutionParameterfv( GLenum target, GLenum pname, GLfloat *params )
    maxParam = 3;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_ARRAY_PARAM( 2, buffer0, TraceReader::TEXT_FLOAT);
    TR.skipLine();
    CHECK_USER_CALL(glGetConvolutionParameterfv)
        UCT.glGetConvolutionParameterfv(param[0].uv32bit, param[1].uv32bit, (GLfloat *)param[2].ptr);
    CHECK_GL_CALL(glGetConvolutionParameterfv)
        JT.glGetConvolutionParameterfv(param[0].uv32bit, param[1].uv32bit, (GLfloat *)param[2].ptr);
}

void STUB_glGetConvolutionParameterfvEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glGetConvolutionParameterfvEXT( GLenum, GLenum, GLfloat * )
    maxParam = 3;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_ARRAY_PARAM( 2, buffer0, TraceReader::TEXT_FLOAT);
    TR.skipLine();
    CHECK_USER_CALL(glGetConvolutionParameterfvEXT)
        UCT.glGetConvolutionParameterfvEXT(param[0].uv32bit, param[1].uv32bit, (GLfloat *)param[2].ptr);
    CHECK_GL_CALL(glGetConvolutionParameterfvEXT)
        JT.glGetConvolutionParameterfvEXT(param[0].uv32bit, param[1].uv32bit, (GLfloat *)param[2].ptr);
}

void STUB_glGetConvolutionParameteriv( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glGetConvolutionParameteriv( GLenum target, GLenum pname, GLint *params )
    maxParam = 3;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_ARRAY_PARAM( 2, buffer0, TraceReader::TEXT_INT);
    TR.skipLine();
    CHECK_USER_CALL(glGetConvolutionParameteriv)
        UCT.glGetConvolutionParameteriv(param[0].uv32bit, param[1].uv32bit, (GLint *)param[2].ptr);
    CHECK_GL_CALL(glGetConvolutionParameteriv)
        JT.glGetConvolutionParameteriv(param[0].uv32bit, param[1].uv32bit, (GLint *)param[2].ptr);
}

void STUB_glGetConvolutionParameterivEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glGetConvolutionParameterivEXT( GLenum, GLenum, GLint * )
    maxParam = 3;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_ARRAY_PARAM( 2, buffer0, TraceReader::TEXT_INT);
    TR.skipLine();
    CHECK_USER_CALL(glGetConvolutionParameterivEXT)
        UCT.glGetConvolutionParameterivEXT(param[0].uv32bit, param[1].uv32bit, (GLint *)param[2].ptr);
    CHECK_GL_CALL(glGetConvolutionParameterivEXT)
        JT.glGetConvolutionParameterivEXT(param[0].uv32bit, param[1].uv32bit, (GLint *)param[2].ptr);
}

void STUB_glGetDetailTexFuncSGIS( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glGetDetailTexFuncSGIS( GLenum, GLfloat * )
    maxParam = 2;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ARRAY_PARAM( 1, buffer0, TraceReader::TEXT_FLOAT);
    TR.skipLine();
    CHECK_USER_CALL(glGetDetailTexFuncSGIS)
        UCT.glGetDetailTexFuncSGIS(param[0].uv32bit, (GLfloat *)param[1].ptr);
    CHECK_GL_CALL(glGetDetailTexFuncSGIS)
        JT.glGetDetailTexFuncSGIS(param[0].uv32bit, (GLfloat *)param[1].ptr);
}

void STUB_glGetDoubleIndexedvEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glGetDoubleIndexedvEXT( GLenum, GLuint, GLdouble * )
    maxParam = 3;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_ARRAY_PARAM( 2, buffer0, TraceReader::TEXT_DOUBLE);
    TR.skipLine();
    CHECK_USER_CALL(glGetDoubleIndexedvEXT)
        UCT.glGetDoubleIndexedvEXT(param[0].uv32bit, param[1].uv32bit, (GLdouble *)param[2].ptr);
    CHECK_GL_CALL(glGetDoubleIndexedvEXT)
        JT.glGetDoubleIndexedvEXT(param[0].uv32bit, param[1].uv32bit, (GLdouble *)param[2].ptr);
}

void STUB_glGetDoublev( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glGetDoublev( GLenum pname, GLdouble *params )
    maxParam = 2;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ARRAY_PARAM( 1, buffer0, TraceReader::TEXT_DOUBLE);
    TR.skipLine();
    CHECK_USER_CALL(glGetDoublev)
        UCT.glGetDoublev(param[0].uv32bit, (GLdouble *)param[1].ptr);
    CHECK_GL_CALL(glGetDoublev)
        JT.glGetDoublev(param[0].uv32bit, (GLdouble *)param[1].ptr);
}

void STUB_glGetError( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // GLenum glGetError(  )
    maxParam = 0;
    TR.skipResult();
    TR.skipLine();
    CHECK_USER_CALL(glGetError)
        UCT.glGetError();
    CHECK_GL_CALL(glGetError)
        JT.glGetError();
}

void STUB_glGetFenceivNV( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glGetFenceivNV( GLuint, GLenum, GLint * )
    maxParam = 3;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_ARRAY_PARAM( 2, buffer0, TraceReader::TEXT_INT);
    TR.skipLine();
    CHECK_USER_CALL(glGetFenceivNV)
        UCT.glGetFenceivNV(param[0].uv32bit, param[1].uv32bit, (GLint *)param[2].ptr);
    CHECK_GL_CALL(glGetFenceivNV)
        JT.glGetFenceivNV(param[0].uv32bit, param[1].uv32bit, (GLint *)param[2].ptr);
}

void STUB_glGetFinalCombinerInputParameterfvNV( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glGetFinalCombinerInputParameterfvNV( GLenum, GLenum, GLfloat * )
    maxParam = 3;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_ARRAY_PARAM( 2, buffer0, TraceReader::TEXT_FLOAT);
    TR.skipLine();
    CHECK_USER_CALL(glGetFinalCombinerInputParameterfvNV)
        UCT.glGetFinalCombinerInputParameterfvNV(param[0].uv32bit, param[1].uv32bit, (GLfloat *)param[2].ptr);
    CHECK_GL_CALL(glGetFinalCombinerInputParameterfvNV)
        JT.glGetFinalCombinerInputParameterfvNV(param[0].uv32bit, param[1].uv32bit, (GLfloat *)param[2].ptr);
}

void STUB_glGetFinalCombinerInputParameterivNV( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glGetFinalCombinerInputParameterivNV( GLenum, GLenum, GLint * )
    maxParam = 3;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_ARRAY_PARAM( 2, buffer0, TraceReader::TEXT_INT);
    TR.skipLine();
    CHECK_USER_CALL(glGetFinalCombinerInputParameterivNV)
        UCT.glGetFinalCombinerInputParameterivNV(param[0].uv32bit, param[1].uv32bit, (GLint *)param[2].ptr);
    CHECK_GL_CALL(glGetFinalCombinerInputParameterivNV)
        JT.glGetFinalCombinerInputParameterivNV(param[0].uv32bit, param[1].uv32bit, (GLint *)param[2].ptr);
}

void STUB_glGetFloatIndexedvEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glGetFloatIndexedvEXT( GLenum, GLuint, GLfloat * )
    maxParam = 3;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_ARRAY_PARAM( 2, buffer0, TraceReader::TEXT_FLOAT);
    TR.skipLine();
    CHECK_USER_CALL(glGetFloatIndexedvEXT)
        UCT.glGetFloatIndexedvEXT(param[0].uv32bit, param[1].uv32bit, (GLfloat *)param[2].ptr);
    CHECK_GL_CALL(glGetFloatIndexedvEXT)
        JT.glGetFloatIndexedvEXT(param[0].uv32bit, param[1].uv32bit, (GLfloat *)param[2].ptr);
}

void STUB_glGetFloatv( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glGetFloatv( GLenum pname, GLfloat *params )
    maxParam = 2;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ARRAY_PARAM( 1, buffer0, TraceReader::TEXT_FLOAT);
    TR.skipLine();
    CHECK_USER_CALL(glGetFloatv)
        UCT.glGetFloatv(param[0].uv32bit, (GLfloat *)param[1].ptr);
    CHECK_GL_CALL(glGetFloatv)
        JT.glGetFloatv(param[0].uv32bit, (GLfloat *)param[1].ptr);
}

void STUB_glGetFogFuncSGIS( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glGetFogFuncSGIS( GLfloat * )
    maxParam = 1;
    char buffer0[16*4096];
    READ_ARRAY_PARAM( 0, buffer0, TraceReader::TEXT_FLOAT);
    TR.skipLine();
    CHECK_USER_CALL(glGetFogFuncSGIS)
        UCT.glGetFogFuncSGIS((GLfloat *)param[0].ptr);
    CHECK_GL_CALL(glGetFogFuncSGIS)
        JT.glGetFogFuncSGIS((GLfloat *)param[0].ptr);
}

void STUB_glGetFragDataLocation( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // GLint glGetFragDataLocation( GLuint, const GLchar * )
    // Call not playable
    TR.skipCall();
}

void STUB_glGetFragDataLocationEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // GLint glGetFragDataLocationEXT( GLuint, const GLchar * )
    // Call not playable
    TR.skipCall();
}

void STUB_glGetFragmentLightfvSGIX( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glGetFragmentLightfvSGIX( GLenum, GLenum, GLfloat * )
    maxParam = 3;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_ARRAY_PARAM( 2, buffer0, TraceReader::TEXT_FLOAT);
    TR.skipLine();
    CHECK_USER_CALL(glGetFragmentLightfvSGIX)
        UCT.glGetFragmentLightfvSGIX(param[0].uv32bit, param[1].uv32bit, (GLfloat *)param[2].ptr);
    CHECK_GL_CALL(glGetFragmentLightfvSGIX)
        JT.glGetFragmentLightfvSGIX(param[0].uv32bit, param[1].uv32bit, (GLfloat *)param[2].ptr);
}

void STUB_glGetFragmentLightivSGIX( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glGetFragmentLightivSGIX( GLenum, GLenum, GLint * )
    maxParam = 3;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_ARRAY_PARAM( 2, buffer0, TraceReader::TEXT_INT);
    TR.skipLine();
    CHECK_USER_CALL(glGetFragmentLightivSGIX)
        UCT.glGetFragmentLightivSGIX(param[0].uv32bit, param[1].uv32bit, (GLint *)param[2].ptr);
    CHECK_GL_CALL(glGetFragmentLightivSGIX)
        JT.glGetFragmentLightivSGIX(param[0].uv32bit, param[1].uv32bit, (GLint *)param[2].ptr);
}

void STUB_glGetFragmentMaterialfvSGIX( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glGetFragmentMaterialfvSGIX( GLenum, GLenum, GLfloat * )
    maxParam = 3;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_ARRAY_PARAM( 2, buffer0, TraceReader::TEXT_FLOAT);
    TR.skipLine();
    CHECK_USER_CALL(glGetFragmentMaterialfvSGIX)
        UCT.glGetFragmentMaterialfvSGIX(param[0].uv32bit, param[1].uv32bit, (GLfloat *)param[2].ptr);
    CHECK_GL_CALL(glGetFragmentMaterialfvSGIX)
        JT.glGetFragmentMaterialfvSGIX(param[0].uv32bit, param[1].uv32bit, (GLfloat *)param[2].ptr);
}

void STUB_glGetFragmentMaterialivSGIX( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glGetFragmentMaterialivSGIX( GLenum, GLenum, GLint * )
    maxParam = 3;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_ARRAY_PARAM( 2, buffer0, TraceReader::TEXT_INT);
    TR.skipLine();
    CHECK_USER_CALL(glGetFragmentMaterialivSGIX)
        UCT.glGetFragmentMaterialivSGIX(param[0].uv32bit, param[1].uv32bit, (GLint *)param[2].ptr);
    CHECK_GL_CALL(glGetFragmentMaterialivSGIX)
        JT.glGetFragmentMaterialivSGIX(param[0].uv32bit, param[1].uv32bit, (GLint *)param[2].ptr);
}

void STUB_glGetFramebufferAttachmentParameteriv( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glGetFramebufferAttachmentParameteriv( GLenum, GLenum, GLenum, GLint * )
    maxParam = 4;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_ENUM_PARAM(2);
    READ_ARRAY_PARAM( 3, buffer0, TraceReader::TEXT_INT);
    TR.skipLine();
    CHECK_USER_CALL(glGetFramebufferAttachmentParameteriv)
        UCT.glGetFramebufferAttachmentParameteriv(param[0].uv32bit, param[1].uv32bit, param[2].uv32bit, (GLint *)param[3].ptr);
    CHECK_GL_CALL(glGetFramebufferAttachmentParameteriv)
        JT.glGetFramebufferAttachmentParameteriv(param[0].uv32bit, param[1].uv32bit, param[2].uv32bit, (GLint *)param[3].ptr);
}

void STUB_glGetFramebufferAttachmentParameterivEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glGetFramebufferAttachmentParameterivEXT( GLenum, GLenum, GLenum, GLint * )
    maxParam = 4;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_ENUM_PARAM(2);
    READ_ARRAY_PARAM( 3, buffer0, TraceReader::TEXT_INT);
    TR.skipLine();
    CHECK_USER_CALL(glGetFramebufferAttachmentParameterivEXT)
        UCT.glGetFramebufferAttachmentParameterivEXT(param[0].uv32bit, param[1].uv32bit, param[2].uv32bit, (GLint *)param[3].ptr);
    CHECK_GL_CALL(glGetFramebufferAttachmentParameterivEXT)
        JT.glGetFramebufferAttachmentParameterivEXT(param[0].uv32bit, param[1].uv32bit, param[2].uv32bit, (GLint *)param[3].ptr);
}

void STUB_glGetFramebufferParameterivEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glGetFramebufferParameterivEXT( GLuint, GLenum, GLint * )
    maxParam = 3;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_ARRAY_PARAM( 2, buffer0, TraceReader::TEXT_INT);
    TR.skipLine();
    CHECK_USER_CALL(glGetFramebufferParameterivEXT)
        UCT.glGetFramebufferParameterivEXT(param[0].uv32bit, param[1].uv32bit, (GLint *)param[2].ptr);
    CHECK_GL_CALL(glGetFramebufferParameterivEXT)
        JT.glGetFramebufferParameterivEXT(param[0].uv32bit, param[1].uv32bit, (GLint *)param[2].ptr);
}

void STUB_glGetHandleARB( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // GLhandleARB glGetHandleARB( GLenum )
    maxParam = 1;
    READ_ENUM_PARAM(0);
    TR.skipResult();
    TR.skipLine();
    CHECK_USER_CALL(glGetHandleARB)
        UCT.glGetHandleARB(param[0].uv32bit);
    CHECK_GL_CALL(glGetHandleARB)
        JT.glGetHandleARB(param[0].uv32bit);
}

void STUB_glGetHistogram( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glGetHistogram( GLenum target, GLboolean reset, GLenum format, GLenum type, GLvoid *values )
    maxParam = 5;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_BOOLEAN_PARAM(1);
    READ_ENUM_PARAM(2);
    READ_ENUM_PARAM(3);
    READ_ARRAY_PARAM( 4, buffer0, TraceReader::TEXT_IGNORE);
    TR.skipLine();
    CHECK_USER_CALL(glGetHistogram)
        UCT.glGetHistogram(param[0].uv32bit, param[1].boolean, param[2].uv32bit, param[3].uv32bit, (GLvoid *)param[4].ptr);
    CHECK_GL_CALL(glGetHistogram)
        JT.glGetHistogram(param[0].uv32bit, param[1].boolean, param[2].uv32bit, param[3].uv32bit, (GLvoid *)param[4].ptr);
}

void STUB_glGetHistogramEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glGetHistogramEXT( GLenum, GLboolean, GLenum, GLenum, GLvoid * )
    maxParam = 5;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_BOOLEAN_PARAM(1);
    READ_ENUM_PARAM(2);
    READ_ENUM_PARAM(3);
    READ_ARRAY_PARAM( 4, buffer0, TraceReader::TEXT_IGNORE);
    TR.skipLine();
    CHECK_USER_CALL(glGetHistogramEXT)
        UCT.glGetHistogramEXT(param[0].uv32bit, param[1].boolean, param[2].uv32bit, param[3].uv32bit, (GLvoid *)param[4].ptr);
    CHECK_GL_CALL(glGetHistogramEXT)
        JT.glGetHistogramEXT(param[0].uv32bit, param[1].boolean, param[2].uv32bit, param[3].uv32bit, (GLvoid *)param[4].ptr);
}

void STUB_glGetHistogramParameterfv( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glGetHistogramParameterfv( GLenum target, GLenum pname, GLfloat *params )
    maxParam = 3;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_ARRAY_PARAM( 2, buffer0, TraceReader::TEXT_FLOAT);
    TR.skipLine();
    CHECK_USER_CALL(glGetHistogramParameterfv)
        UCT.glGetHistogramParameterfv(param[0].uv32bit, param[1].uv32bit, (GLfloat *)param[2].ptr);
    CHECK_GL_CALL(glGetHistogramParameterfv)
        JT.glGetHistogramParameterfv(param[0].uv32bit, param[1].uv32bit, (GLfloat *)param[2].ptr);
}

void STUB_glGetHistogramParameterfvEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glGetHistogramParameterfvEXT( GLenum, GLenum, GLfloat * )
    maxParam = 3;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_ARRAY_PARAM( 2, buffer0, TraceReader::TEXT_FLOAT);
    TR.skipLine();
    CHECK_USER_CALL(glGetHistogramParameterfvEXT)
        UCT.glGetHistogramParameterfvEXT(param[0].uv32bit, param[1].uv32bit, (GLfloat *)param[2].ptr);
    CHECK_GL_CALL(glGetHistogramParameterfvEXT)
        JT.glGetHistogramParameterfvEXT(param[0].uv32bit, param[1].uv32bit, (GLfloat *)param[2].ptr);
}

void STUB_glGetHistogramParameteriv( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glGetHistogramParameteriv( GLenum target, GLenum pname, GLint *params )
    maxParam = 3;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_ARRAY_PARAM( 2, buffer0, TraceReader::TEXT_INT);
    TR.skipLine();
    CHECK_USER_CALL(glGetHistogramParameteriv)
        UCT.glGetHistogramParameteriv(param[0].uv32bit, param[1].uv32bit, (GLint *)param[2].ptr);
    CHECK_GL_CALL(glGetHistogramParameteriv)
        JT.glGetHistogramParameteriv(param[0].uv32bit, param[1].uv32bit, (GLint *)param[2].ptr);
}

void STUB_glGetHistogramParameterivEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glGetHistogramParameterivEXT( GLenum, GLenum, GLint * )
    maxParam = 3;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_ARRAY_PARAM( 2, buffer0, TraceReader::TEXT_INT);
    TR.skipLine();
    CHECK_USER_CALL(glGetHistogramParameterivEXT)
        UCT.glGetHistogramParameterivEXT(param[0].uv32bit, param[1].uv32bit, (GLint *)param[2].ptr);
    CHECK_GL_CALL(glGetHistogramParameterivEXT)
        JT.glGetHistogramParameterivEXT(param[0].uv32bit, param[1].uv32bit, (GLint *)param[2].ptr);
}

void STUB_glGetImageTransformParameterfvHP( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glGetImageTransformParameterfvHP( GLenum, GLenum, GLfloat * )
    maxParam = 3;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_ARRAY_PARAM( 2, buffer0, TraceReader::TEXT_FLOAT);
    TR.skipLine();
    CHECK_USER_CALL(glGetImageTransformParameterfvHP)
        UCT.glGetImageTransformParameterfvHP(param[0].uv32bit, param[1].uv32bit, (GLfloat *)param[2].ptr);
    CHECK_GL_CALL(glGetImageTransformParameterfvHP)
        JT.glGetImageTransformParameterfvHP(param[0].uv32bit, param[1].uv32bit, (GLfloat *)param[2].ptr);
}

void STUB_glGetImageTransformParameterivHP( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glGetImageTransformParameterivHP( GLenum, GLenum, GLint * )
    maxParam = 3;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_ARRAY_PARAM( 2, buffer0, TraceReader::TEXT_INT);
    TR.skipLine();
    CHECK_USER_CALL(glGetImageTransformParameterivHP)
        UCT.glGetImageTransformParameterivHP(param[0].uv32bit, param[1].uv32bit, (GLint *)param[2].ptr);
    CHECK_GL_CALL(glGetImageTransformParameterivHP)
        JT.glGetImageTransformParameterivHP(param[0].uv32bit, param[1].uv32bit, (GLint *)param[2].ptr);
}

void STUB_glGetInfoLogARB( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glGetInfoLogARB( GLhandleARB, GLsizei, GLsizei *, GLcharARB * )
    maxParam = 4;
    char buffer0[16*4096];
    char buffer1[16*4096];
    READ_ENUM_PARAM(0);
    READ_PARAM(v32bit,1);
    READ_ARRAY_PARAM( 2, buffer0, TraceReader::TEXT_INT);
    READ_ARRAY_PARAM( 3, buffer1, TraceReader::TEXT_BYTE);
    TR.skipLine();
    CHECK_USER_CALL(glGetInfoLogARB)
        UCT.glGetInfoLogARB(param[0].uv32bit, param[1].v32bit, (GLsizei *)param[2].ptr, (GLcharARB *)param[3].ptr);
    CHECK_GL_CALL(glGetInfoLogARB)
        JT.glGetInfoLogARB(param[0].uv32bit, param[1].v32bit, (GLsizei *)param[2].ptr, (GLcharARB *)param[3].ptr);
}

void STUB_glGetInstrumentsSGIX( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // GLint glGetInstrumentsSGIX(  )
    maxParam = 0;
    TR.skipResult();
    TR.skipLine();
    CHECK_USER_CALL(glGetInstrumentsSGIX)
        UCT.glGetInstrumentsSGIX();
    CHECK_GL_CALL(glGetInstrumentsSGIX)
        JT.glGetInstrumentsSGIX();
}

void STUB_glGetIntegerIndexedvEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glGetIntegerIndexedvEXT( GLenum, GLuint, GLint * )
    maxParam = 3;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_ARRAY_PARAM( 2, buffer0, TraceReader::TEXT_INT);
    TR.skipLine();
    CHECK_USER_CALL(glGetIntegerIndexedvEXT)
        UCT.glGetIntegerIndexedvEXT(param[0].uv32bit, param[1].uv32bit, (GLint *)param[2].ptr);
    CHECK_GL_CALL(glGetIntegerIndexedvEXT)
        JT.glGetIntegerIndexedvEXT(param[0].uv32bit, param[1].uv32bit, (GLint *)param[2].ptr);
}

void STUB_glGetIntegeri_v( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glGetIntegeri_v( GLenum, GLuint, GLint * )
    maxParam = 3;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_ARRAY_PARAM( 2, buffer0, TraceReader::TEXT_INT);
    TR.skipLine();
    CHECK_USER_CALL(glGetIntegeri_v)
        UCT.glGetIntegeri_v(param[0].uv32bit, param[1].uv32bit, (GLint *)param[2].ptr);
    CHECK_GL_CALL(glGetIntegeri_v)
        JT.glGetIntegeri_v(param[0].uv32bit, param[1].uv32bit, (GLint *)param[2].ptr);
}

void STUB_glGetIntegerv( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glGetIntegerv( GLenum pname, GLint *params )
    maxParam = 2;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ARRAY_PARAM( 1, buffer0, TraceReader::TEXT_INT);
    TR.skipLine();
    CHECK_USER_CALL(glGetIntegerv)
        UCT.glGetIntegerv(param[0].uv32bit, (GLint *)param[1].ptr);
    CHECK_GL_CALL(glGetIntegerv)
        JT.glGetIntegerv(param[0].uv32bit, (GLint *)param[1].ptr);
}

void STUB_glGetInvariantBooleanvEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glGetInvariantBooleanvEXT( GLuint, GLenum, GLboolean * )
    maxParam = 3;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_ARRAY_PARAM( 2, buffer0, TraceReader::TEXT_BYTE);
    TR.skipLine();
    CHECK_USER_CALL(glGetInvariantBooleanvEXT)
        UCT.glGetInvariantBooleanvEXT(param[0].uv32bit, param[1].uv32bit, (GLboolean *)param[2].ptr);
    CHECK_GL_CALL(glGetInvariantBooleanvEXT)
        JT.glGetInvariantBooleanvEXT(param[0].uv32bit, param[1].uv32bit, (GLboolean *)param[2].ptr);
}

void STUB_glGetInvariantFloatvEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glGetInvariantFloatvEXT( GLuint, GLenum, GLfloat * )
    maxParam = 3;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_ARRAY_PARAM( 2, buffer0, TraceReader::TEXT_FLOAT);
    TR.skipLine();
    CHECK_USER_CALL(glGetInvariantFloatvEXT)
        UCT.glGetInvariantFloatvEXT(param[0].uv32bit, param[1].uv32bit, (GLfloat *)param[2].ptr);
    CHECK_GL_CALL(glGetInvariantFloatvEXT)
        JT.glGetInvariantFloatvEXT(param[0].uv32bit, param[1].uv32bit, (GLfloat *)param[2].ptr);
}

void STUB_glGetInvariantIntegervEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glGetInvariantIntegervEXT( GLuint, GLenum, GLint * )
    maxParam = 3;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_ARRAY_PARAM( 2, buffer0, TraceReader::TEXT_INT);
    TR.skipLine();
    CHECK_USER_CALL(glGetInvariantIntegervEXT)
        UCT.glGetInvariantIntegervEXT(param[0].uv32bit, param[1].uv32bit, (GLint *)param[2].ptr);
    CHECK_GL_CALL(glGetInvariantIntegervEXT)
        JT.glGetInvariantIntegervEXT(param[0].uv32bit, param[1].uv32bit, (GLint *)param[2].ptr);
}

void STUB_glGetLightfv( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glGetLightfv( GLenum light, GLenum pname, GLfloat *params )
    maxParam = 3;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_ARRAY_PARAM( 2, buffer0, TraceReader::TEXT_FLOAT);
    TR.skipLine();
    CHECK_USER_CALL(glGetLightfv)
        UCT.glGetLightfv(param[0].uv32bit, param[1].uv32bit, (GLfloat *)param[2].ptr);
    CHECK_GL_CALL(glGetLightfv)
        JT.glGetLightfv(param[0].uv32bit, param[1].uv32bit, (GLfloat *)param[2].ptr);
}

void STUB_glGetLightiv( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glGetLightiv( GLenum light, GLenum pname, GLint *params )
    maxParam = 3;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_ARRAY_PARAM( 2, buffer0, TraceReader::TEXT_INT);
    TR.skipLine();
    CHECK_USER_CALL(glGetLightiv)
        UCT.glGetLightiv(param[0].uv32bit, param[1].uv32bit, (GLint *)param[2].ptr);
    CHECK_GL_CALL(glGetLightiv)
        JT.glGetLightiv(param[0].uv32bit, param[1].uv32bit, (GLint *)param[2].ptr);
}

void STUB_glGetListParameterfvSGIX( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glGetListParameterfvSGIX( GLuint, GLenum, GLfloat * )
    maxParam = 3;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_ARRAY_PARAM( 2, buffer0, TraceReader::TEXT_FLOAT);
    TR.skipLine();
    CHECK_USER_CALL(glGetListParameterfvSGIX)
        UCT.glGetListParameterfvSGIX(param[0].uv32bit, param[1].uv32bit, (GLfloat *)param[2].ptr);
    CHECK_GL_CALL(glGetListParameterfvSGIX)
        JT.glGetListParameterfvSGIX(param[0].uv32bit, param[1].uv32bit, (GLfloat *)param[2].ptr);
}

void STUB_glGetListParameterivSGIX( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glGetListParameterivSGIX( GLuint, GLenum, GLint * )
    maxParam = 3;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_ARRAY_PARAM( 2, buffer0, TraceReader::TEXT_INT);
    TR.skipLine();
    CHECK_USER_CALL(glGetListParameterivSGIX)
        UCT.glGetListParameterivSGIX(param[0].uv32bit, param[1].uv32bit, (GLint *)param[2].ptr);
    CHECK_GL_CALL(glGetListParameterivSGIX)
        JT.glGetListParameterivSGIX(param[0].uv32bit, param[1].uv32bit, (GLint *)param[2].ptr);
}

void STUB_glGetLocalConstantBooleanvEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glGetLocalConstantBooleanvEXT( GLuint, GLenum, GLboolean * )
    maxParam = 3;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_ARRAY_PARAM( 2, buffer0, TraceReader::TEXT_BYTE);
    TR.skipLine();
    CHECK_USER_CALL(glGetLocalConstantBooleanvEXT)
        UCT.glGetLocalConstantBooleanvEXT(param[0].uv32bit, param[1].uv32bit, (GLboolean *)param[2].ptr);
    CHECK_GL_CALL(glGetLocalConstantBooleanvEXT)
        JT.glGetLocalConstantBooleanvEXT(param[0].uv32bit, param[1].uv32bit, (GLboolean *)param[2].ptr);
}

void STUB_glGetLocalConstantFloatvEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glGetLocalConstantFloatvEXT( GLuint, GLenum, GLfloat * )
    maxParam = 3;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_ARRAY_PARAM( 2, buffer0, TraceReader::TEXT_FLOAT);
    TR.skipLine();
    CHECK_USER_CALL(glGetLocalConstantFloatvEXT)
        UCT.glGetLocalConstantFloatvEXT(param[0].uv32bit, param[1].uv32bit, (GLfloat *)param[2].ptr);
    CHECK_GL_CALL(glGetLocalConstantFloatvEXT)
        JT.glGetLocalConstantFloatvEXT(param[0].uv32bit, param[1].uv32bit, (GLfloat *)param[2].ptr);
}

void STUB_glGetLocalConstantIntegervEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glGetLocalConstantIntegervEXT( GLuint, GLenum, GLint * )
    maxParam = 3;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_ARRAY_PARAM( 2, buffer0, TraceReader::TEXT_INT);
    TR.skipLine();
    CHECK_USER_CALL(glGetLocalConstantIntegervEXT)
        UCT.glGetLocalConstantIntegervEXT(param[0].uv32bit, param[1].uv32bit, (GLint *)param[2].ptr);
    CHECK_GL_CALL(glGetLocalConstantIntegervEXT)
        JT.glGetLocalConstantIntegervEXT(param[0].uv32bit, param[1].uv32bit, (GLint *)param[2].ptr);
}

void STUB_glGetMapAttribParameterfvNV( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glGetMapAttribParameterfvNV( GLenum, GLuint, GLenum, GLfloat * )
    maxParam = 4;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_ENUM_PARAM(2);
    READ_ARRAY_PARAM( 3, buffer0, TraceReader::TEXT_FLOAT);
    TR.skipLine();
    CHECK_USER_CALL(glGetMapAttribParameterfvNV)
        UCT.glGetMapAttribParameterfvNV(param[0].uv32bit, param[1].uv32bit, param[2].uv32bit, (GLfloat *)param[3].ptr);
    CHECK_GL_CALL(glGetMapAttribParameterfvNV)
        JT.glGetMapAttribParameterfvNV(param[0].uv32bit, param[1].uv32bit, param[2].uv32bit, (GLfloat *)param[3].ptr);
}

void STUB_glGetMapAttribParameterivNV( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glGetMapAttribParameterivNV( GLenum, GLuint, GLenum, GLint * )
    maxParam = 4;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_ENUM_PARAM(2);
    READ_ARRAY_PARAM( 3, buffer0, TraceReader::TEXT_INT);
    TR.skipLine();
    CHECK_USER_CALL(glGetMapAttribParameterivNV)
        UCT.glGetMapAttribParameterivNV(param[0].uv32bit, param[1].uv32bit, param[2].uv32bit, (GLint *)param[3].ptr);
    CHECK_GL_CALL(glGetMapAttribParameterivNV)
        JT.glGetMapAttribParameterivNV(param[0].uv32bit, param[1].uv32bit, param[2].uv32bit, (GLint *)param[3].ptr);
}

void STUB_glGetMapControlPointsNV( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glGetMapControlPointsNV( GLenum, GLuint, GLenum, GLsizei, GLsizei, GLboolean, GLvoid * )
    maxParam = 7;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_ENUM_PARAM(2);
    READ_PARAM(v32bit,3);
    READ_PARAM(v32bit,4);
    READ_BOOLEAN_PARAM(5);
    READ_ARRAY_PARAM( 6, buffer0, TraceReader::TEXT_IGNORE);
    TR.skipLine();
    CHECK_USER_CALL(glGetMapControlPointsNV)
        UCT.glGetMapControlPointsNV(param[0].uv32bit, param[1].uv32bit, param[2].uv32bit, param[3].v32bit, param[4].v32bit, param[5].boolean, (GLvoid *)param[6].ptr);
    CHECK_GL_CALL(glGetMapControlPointsNV)
        JT.glGetMapControlPointsNV(param[0].uv32bit, param[1].uv32bit, param[2].uv32bit, param[3].v32bit, param[4].v32bit, param[5].boolean, (GLvoid *)param[6].ptr);
}

void STUB_glGetMapParameterfvNV( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glGetMapParameterfvNV( GLenum, GLenum, GLfloat * )
    maxParam = 3;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_ARRAY_PARAM( 2, buffer0, TraceReader::TEXT_FLOAT);
    TR.skipLine();
    CHECK_USER_CALL(glGetMapParameterfvNV)
        UCT.glGetMapParameterfvNV(param[0].uv32bit, param[1].uv32bit, (GLfloat *)param[2].ptr);
    CHECK_GL_CALL(glGetMapParameterfvNV)
        JT.glGetMapParameterfvNV(param[0].uv32bit, param[1].uv32bit, (GLfloat *)param[2].ptr);
}

void STUB_glGetMapParameterivNV( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glGetMapParameterivNV( GLenum, GLenum, GLint * )
    maxParam = 3;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_ARRAY_PARAM( 2, buffer0, TraceReader::TEXT_INT);
    TR.skipLine();
    CHECK_USER_CALL(glGetMapParameterivNV)
        UCT.glGetMapParameterivNV(param[0].uv32bit, param[1].uv32bit, (GLint *)param[2].ptr);
    CHECK_GL_CALL(glGetMapParameterivNV)
        JT.glGetMapParameterivNV(param[0].uv32bit, param[1].uv32bit, (GLint *)param[2].ptr);
}

void STUB_glGetMapdv( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glGetMapdv( GLenum target, GLenum query, GLdouble *v )
    maxParam = 3;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_ARRAY_PARAM( 2, buffer0, TraceReader::TEXT_DOUBLE);
    TR.skipLine();
    CHECK_USER_CALL(glGetMapdv)
        UCT.glGetMapdv(param[0].uv32bit, param[1].uv32bit, (GLdouble *)param[2].ptr);
    CHECK_GL_CALL(glGetMapdv)
        JT.glGetMapdv(param[0].uv32bit, param[1].uv32bit, (GLdouble *)param[2].ptr);
}

void STUB_glGetMapfv( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glGetMapfv( GLenum target, GLenum query, GLfloat *v )
    maxParam = 3;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_ARRAY_PARAM( 2, buffer0, TraceReader::TEXT_FLOAT);
    TR.skipLine();
    CHECK_USER_CALL(glGetMapfv)
        UCT.glGetMapfv(param[0].uv32bit, param[1].uv32bit, (GLfloat *)param[2].ptr);
    CHECK_GL_CALL(glGetMapfv)
        JT.glGetMapfv(param[0].uv32bit, param[1].uv32bit, (GLfloat *)param[2].ptr);
}

void STUB_glGetMapiv( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glGetMapiv( GLenum target, GLenum query, GLint *v )
    maxParam = 3;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_ARRAY_PARAM( 2, buffer0, TraceReader::TEXT_INT);
    TR.skipLine();
    CHECK_USER_CALL(glGetMapiv)
        UCT.glGetMapiv(param[0].uv32bit, param[1].uv32bit, (GLint *)param[2].ptr);
    CHECK_GL_CALL(glGetMapiv)
        JT.glGetMapiv(param[0].uv32bit, param[1].uv32bit, (GLint *)param[2].ptr);
}

void STUB_glGetMaterialfv( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glGetMaterialfv( GLenum face, GLenum pname, GLfloat *params )
    maxParam = 3;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_ARRAY_PARAM( 2, buffer0, TraceReader::TEXT_FLOAT);
    TR.skipLine();
    CHECK_USER_CALL(glGetMaterialfv)
        UCT.glGetMaterialfv(param[0].uv32bit, param[1].uv32bit, (GLfloat *)param[2].ptr);
    CHECK_GL_CALL(glGetMaterialfv)
        JT.glGetMaterialfv(param[0].uv32bit, param[1].uv32bit, (GLfloat *)param[2].ptr);
}

void STUB_glGetMaterialiv( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glGetMaterialiv( GLenum face, GLenum pname, GLint *params )
    maxParam = 3;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_ARRAY_PARAM( 2, buffer0, TraceReader::TEXT_INT);
    TR.skipLine();
    CHECK_USER_CALL(glGetMaterialiv)
        UCT.glGetMaterialiv(param[0].uv32bit, param[1].uv32bit, (GLint *)param[2].ptr);
    CHECK_GL_CALL(glGetMaterialiv)
        JT.glGetMaterialiv(param[0].uv32bit, param[1].uv32bit, (GLint *)param[2].ptr);
}

void STUB_glGetMinmax( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glGetMinmax( GLenum target, GLboolean reset, GLenum format, GLenum types, GLvoid *values )
    maxParam = 5;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_BOOLEAN_PARAM(1);
    READ_ENUM_PARAM(2);
    READ_ENUM_PARAM(3);
    READ_ARRAY_PARAM( 4, buffer0, TraceReader::TEXT_IGNORE);
    TR.skipLine();
    CHECK_USER_CALL(glGetMinmax)
        UCT.glGetMinmax(param[0].uv32bit, param[1].boolean, param[2].uv32bit, param[3].uv32bit, (GLvoid *)param[4].ptr);
    CHECK_GL_CALL(glGetMinmax)
        JT.glGetMinmax(param[0].uv32bit, param[1].boolean, param[2].uv32bit, param[3].uv32bit, (GLvoid *)param[4].ptr);
}

void STUB_glGetMinmaxEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glGetMinmaxEXT( GLenum, GLboolean, GLenum, GLenum, GLvoid * )
    maxParam = 5;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_BOOLEAN_PARAM(1);
    READ_ENUM_PARAM(2);
    READ_ENUM_PARAM(3);
    READ_ARRAY_PARAM( 4, buffer0, TraceReader::TEXT_IGNORE);
    TR.skipLine();
    CHECK_USER_CALL(glGetMinmaxEXT)
        UCT.glGetMinmaxEXT(param[0].uv32bit, param[1].boolean, param[2].uv32bit, param[3].uv32bit, (GLvoid *)param[4].ptr);
    CHECK_GL_CALL(glGetMinmaxEXT)
        JT.glGetMinmaxEXT(param[0].uv32bit, param[1].boolean, param[2].uv32bit, param[3].uv32bit, (GLvoid *)param[4].ptr);
}

void STUB_glGetMinmaxParameterfv( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glGetMinmaxParameterfv( GLenum target, GLenum pname, GLfloat *params )
    maxParam = 3;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_ARRAY_PARAM( 2, buffer0, TraceReader::TEXT_FLOAT);
    TR.skipLine();
    CHECK_USER_CALL(glGetMinmaxParameterfv)
        UCT.glGetMinmaxParameterfv(param[0].uv32bit, param[1].uv32bit, (GLfloat *)param[2].ptr);
    CHECK_GL_CALL(glGetMinmaxParameterfv)
        JT.glGetMinmaxParameterfv(param[0].uv32bit, param[1].uv32bit, (GLfloat *)param[2].ptr);
}

void STUB_glGetMinmaxParameterfvEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glGetMinmaxParameterfvEXT( GLenum, GLenum, GLfloat * )
    maxParam = 3;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_ARRAY_PARAM( 2, buffer0, TraceReader::TEXT_FLOAT);
    TR.skipLine();
    CHECK_USER_CALL(glGetMinmaxParameterfvEXT)
        UCT.glGetMinmaxParameterfvEXT(param[0].uv32bit, param[1].uv32bit, (GLfloat *)param[2].ptr);
    CHECK_GL_CALL(glGetMinmaxParameterfvEXT)
        JT.glGetMinmaxParameterfvEXT(param[0].uv32bit, param[1].uv32bit, (GLfloat *)param[2].ptr);
}

void STUB_glGetMinmaxParameteriv( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glGetMinmaxParameteriv( GLenum target, GLenum pname, GLint *params )
    maxParam = 3;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_ARRAY_PARAM( 2, buffer0, TraceReader::TEXT_INT);
    TR.skipLine();
    CHECK_USER_CALL(glGetMinmaxParameteriv)
        UCT.glGetMinmaxParameteriv(param[0].uv32bit, param[1].uv32bit, (GLint *)param[2].ptr);
    CHECK_GL_CALL(glGetMinmaxParameteriv)
        JT.glGetMinmaxParameteriv(param[0].uv32bit, param[1].uv32bit, (GLint *)param[2].ptr);
}

void STUB_glGetMinmaxParameterivEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glGetMinmaxParameterivEXT( GLenum, GLenum, GLint * )
    maxParam = 3;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_ARRAY_PARAM( 2, buffer0, TraceReader::TEXT_INT);
    TR.skipLine();
    CHECK_USER_CALL(glGetMinmaxParameterivEXT)
        UCT.glGetMinmaxParameterivEXT(param[0].uv32bit, param[1].uv32bit, (GLint *)param[2].ptr);
    CHECK_GL_CALL(glGetMinmaxParameterivEXT)
        JT.glGetMinmaxParameterivEXT(param[0].uv32bit, param[1].uv32bit, (GLint *)param[2].ptr);
}

void STUB_glGetMultiTexEnvfvEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glGetMultiTexEnvfvEXT( GLenum, GLenum, GLenum, GLfloat * )
    maxParam = 4;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_ENUM_PARAM(2);
    READ_ARRAY_PARAM( 3, buffer0, TraceReader::TEXT_FLOAT);
    TR.skipLine();
    CHECK_USER_CALL(glGetMultiTexEnvfvEXT)
        UCT.glGetMultiTexEnvfvEXT(param[0].uv32bit, param[1].uv32bit, param[2].uv32bit, (GLfloat *)param[3].ptr);
    CHECK_GL_CALL(glGetMultiTexEnvfvEXT)
        JT.glGetMultiTexEnvfvEXT(param[0].uv32bit, param[1].uv32bit, param[2].uv32bit, (GLfloat *)param[3].ptr);
}

void STUB_glGetMultiTexEnvivEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glGetMultiTexEnvivEXT( GLenum, GLenum, GLenum, GLint * )
    maxParam = 4;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_ENUM_PARAM(2);
    READ_ARRAY_PARAM( 3, buffer0, TraceReader::TEXT_INT);
    TR.skipLine();
    CHECK_USER_CALL(glGetMultiTexEnvivEXT)
        UCT.glGetMultiTexEnvivEXT(param[0].uv32bit, param[1].uv32bit, param[2].uv32bit, (GLint *)param[3].ptr);
    CHECK_GL_CALL(glGetMultiTexEnvivEXT)
        JT.glGetMultiTexEnvivEXT(param[0].uv32bit, param[1].uv32bit, param[2].uv32bit, (GLint *)param[3].ptr);
}

void STUB_glGetMultiTexGendvEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glGetMultiTexGendvEXT( GLenum, GLenum, GLenum, GLdouble * )
    maxParam = 4;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_ENUM_PARAM(2);
    READ_ARRAY_PARAM( 3, buffer0, TraceReader::TEXT_DOUBLE);
    TR.skipLine();
    CHECK_USER_CALL(glGetMultiTexGendvEXT)
        UCT.glGetMultiTexGendvEXT(param[0].uv32bit, param[1].uv32bit, param[2].uv32bit, (GLdouble *)param[3].ptr);
    CHECK_GL_CALL(glGetMultiTexGendvEXT)
        JT.glGetMultiTexGendvEXT(param[0].uv32bit, param[1].uv32bit, param[2].uv32bit, (GLdouble *)param[3].ptr);
}

void STUB_glGetMultiTexGenfvEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glGetMultiTexGenfvEXT( GLenum, GLenum, GLenum, GLfloat * )
    maxParam = 4;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_ENUM_PARAM(2);
    READ_ARRAY_PARAM( 3, buffer0, TraceReader::TEXT_FLOAT);
    TR.skipLine();
    CHECK_USER_CALL(glGetMultiTexGenfvEXT)
        UCT.glGetMultiTexGenfvEXT(param[0].uv32bit, param[1].uv32bit, param[2].uv32bit, (GLfloat *)param[3].ptr);
    CHECK_GL_CALL(glGetMultiTexGenfvEXT)
        JT.glGetMultiTexGenfvEXT(param[0].uv32bit, param[1].uv32bit, param[2].uv32bit, (GLfloat *)param[3].ptr);
}

void STUB_glGetMultiTexGenivEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glGetMultiTexGenivEXT( GLenum, GLenum, GLenum, GLint * )
    maxParam = 4;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_ENUM_PARAM(2);
    READ_ARRAY_PARAM( 3, buffer0, TraceReader::TEXT_INT);
    TR.skipLine();
    CHECK_USER_CALL(glGetMultiTexGenivEXT)
        UCT.glGetMultiTexGenivEXT(param[0].uv32bit, param[1].uv32bit, param[2].uv32bit, (GLint *)param[3].ptr);
    CHECK_GL_CALL(glGetMultiTexGenivEXT)
        JT.glGetMultiTexGenivEXT(param[0].uv32bit, param[1].uv32bit, param[2].uv32bit, (GLint *)param[3].ptr);
}

void STUB_glGetMultiTexImageEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glGetMultiTexImageEXT( GLenum, GLenum, GLint, GLenum, GLenum, GLvoid * )
    maxParam = 6;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_PARAM(v32bit,2);
    READ_ENUM_PARAM(3);
    READ_ENUM_PARAM(4);
    READ_ARRAY_PARAM( 5, buffer0, TraceReader::TEXT_IGNORE);
    TR.skipLine();
    CHECK_USER_CALL(glGetMultiTexImageEXT)
        UCT.glGetMultiTexImageEXT(param[0].uv32bit, param[1].uv32bit, param[2].v32bit, param[3].uv32bit, param[4].uv32bit, (GLvoid *)param[5].ptr);
    CHECK_GL_CALL(glGetMultiTexImageEXT)
        JT.glGetMultiTexImageEXT(param[0].uv32bit, param[1].uv32bit, param[2].v32bit, param[3].uv32bit, param[4].uv32bit, (GLvoid *)param[5].ptr);
}

void STUB_glGetMultiTexLevelParameterfvEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glGetMultiTexLevelParameterfvEXT( GLenum, GLenum, GLint, GLenum, GLfloat * )
    maxParam = 5;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_PARAM(v32bit,2);
    READ_ENUM_PARAM(3);
    READ_ARRAY_PARAM( 4, buffer0, TraceReader::TEXT_FLOAT);
    TR.skipLine();
    CHECK_USER_CALL(glGetMultiTexLevelParameterfvEXT)
        UCT.glGetMultiTexLevelParameterfvEXT(param[0].uv32bit, param[1].uv32bit, param[2].v32bit, param[3].uv32bit, (GLfloat *)param[4].ptr);
    CHECK_GL_CALL(glGetMultiTexLevelParameterfvEXT)
        JT.glGetMultiTexLevelParameterfvEXT(param[0].uv32bit, param[1].uv32bit, param[2].v32bit, param[3].uv32bit, (GLfloat *)param[4].ptr);
}

void STUB_glGetMultiTexLevelParameterivEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glGetMultiTexLevelParameterivEXT( GLenum, GLenum, GLint, GLenum, GLint * )
    maxParam = 5;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_PARAM(v32bit,2);
    READ_ENUM_PARAM(3);
    READ_ARRAY_PARAM( 4, buffer0, TraceReader::TEXT_INT);
    TR.skipLine();
    CHECK_USER_CALL(glGetMultiTexLevelParameterivEXT)
        UCT.glGetMultiTexLevelParameterivEXT(param[0].uv32bit, param[1].uv32bit, param[2].v32bit, param[3].uv32bit, (GLint *)param[4].ptr);
    CHECK_GL_CALL(glGetMultiTexLevelParameterivEXT)
        JT.glGetMultiTexLevelParameterivEXT(param[0].uv32bit, param[1].uv32bit, param[2].v32bit, param[3].uv32bit, (GLint *)param[4].ptr);
}

void STUB_glGetMultiTexParameterIivEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glGetMultiTexParameterIivEXT( GLenum, GLenum, GLenum, GLint * )
    maxParam = 4;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_ENUM_PARAM(2);
    READ_ARRAY_PARAM( 3, buffer0, TraceReader::TEXT_INT);
    TR.skipLine();
    CHECK_USER_CALL(glGetMultiTexParameterIivEXT)
        UCT.glGetMultiTexParameterIivEXT(param[0].uv32bit, param[1].uv32bit, param[2].uv32bit, (GLint *)param[3].ptr);
    CHECK_GL_CALL(glGetMultiTexParameterIivEXT)
        JT.glGetMultiTexParameterIivEXT(param[0].uv32bit, param[1].uv32bit, param[2].uv32bit, (GLint *)param[3].ptr);
}

void STUB_glGetMultiTexParameterIuivEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glGetMultiTexParameterIuivEXT( GLenum, GLenum, GLenum, GLuint * )
    maxParam = 4;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_ENUM_PARAM(2);
    READ_ARRAY_PARAM( 3, buffer0, TraceReader::TEXT_INT);
    TR.skipLine();
    CHECK_USER_CALL(glGetMultiTexParameterIuivEXT)
        UCT.glGetMultiTexParameterIuivEXT(param[0].uv32bit, param[1].uv32bit, param[2].uv32bit, (GLuint *)param[3].ptr);
    CHECK_GL_CALL(glGetMultiTexParameterIuivEXT)
        JT.glGetMultiTexParameterIuivEXT(param[0].uv32bit, param[1].uv32bit, param[2].uv32bit, (GLuint *)param[3].ptr);
}

void STUB_glGetMultiTexParameterfvEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glGetMultiTexParameterfvEXT( GLenum, GLenum, GLenum, GLfloat * )
    maxParam = 4;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_ENUM_PARAM(2);
    READ_ARRAY_PARAM( 3, buffer0, TraceReader::TEXT_FLOAT);
    TR.skipLine();
    CHECK_USER_CALL(glGetMultiTexParameterfvEXT)
        UCT.glGetMultiTexParameterfvEXT(param[0].uv32bit, param[1].uv32bit, param[2].uv32bit, (GLfloat *)param[3].ptr);
    CHECK_GL_CALL(glGetMultiTexParameterfvEXT)
        JT.glGetMultiTexParameterfvEXT(param[0].uv32bit, param[1].uv32bit, param[2].uv32bit, (GLfloat *)param[3].ptr);
}

void STUB_glGetMultiTexParameterivEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glGetMultiTexParameterivEXT( GLenum, GLenum, GLenum, GLint * )
    maxParam = 4;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_ENUM_PARAM(2);
    READ_ARRAY_PARAM( 3, buffer0, TraceReader::TEXT_INT);
    TR.skipLine();
    CHECK_USER_CALL(glGetMultiTexParameterivEXT)
        UCT.glGetMultiTexParameterivEXT(param[0].uv32bit, param[1].uv32bit, param[2].uv32bit, (GLint *)param[3].ptr);
    CHECK_GL_CALL(glGetMultiTexParameterivEXT)
        JT.glGetMultiTexParameterivEXT(param[0].uv32bit, param[1].uv32bit, param[2].uv32bit, (GLint *)param[3].ptr);
}

void STUB_glGetMultisamplefvNV( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glGetMultisamplefvNV( GLenum, GLuint, GLfloat * )
    maxParam = 3;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_ARRAY_PARAM( 2, buffer0, TraceReader::TEXT_FLOAT);
    TR.skipLine();
    CHECK_USER_CALL(glGetMultisamplefvNV)
        UCT.glGetMultisamplefvNV(param[0].uv32bit, param[1].uv32bit, (GLfloat *)param[2].ptr);
    CHECK_GL_CALL(glGetMultisamplefvNV)
        JT.glGetMultisamplefvNV(param[0].uv32bit, param[1].uv32bit, (GLfloat *)param[2].ptr);
}

void STUB_glGetNamedBufferParameterivEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glGetNamedBufferParameterivEXT( GLuint, GLenum, GLint * )
    maxParam = 3;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_ARRAY_PARAM( 2, buffer0, TraceReader::TEXT_INT);
    TR.skipLine();
    CHECK_USER_CALL(glGetNamedBufferParameterivEXT)
        UCT.glGetNamedBufferParameterivEXT(param[0].uv32bit, param[1].uv32bit, (GLint *)param[2].ptr);
    CHECK_GL_CALL(glGetNamedBufferParameterivEXT)
        JT.glGetNamedBufferParameterivEXT(param[0].uv32bit, param[1].uv32bit, (GLint *)param[2].ptr);
}

void STUB_glGetNamedBufferPointervEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glGetNamedBufferPointervEXT( GLuint, GLenum, GLvoid ** )
    maxParam = 3;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_ARRAY_PARAM( 2, buffer0, TraceReader::TEXT_IGNORE);
    TR.skipLine();
    CHECK_USER_CALL(glGetNamedBufferPointervEXT)
        UCT.glGetNamedBufferPointervEXT(param[0].uv32bit, param[1].uv32bit, (GLvoid **)param[2].ptr);
    CHECK_GL_CALL(glGetNamedBufferPointervEXT)
        JT.glGetNamedBufferPointervEXT(param[0].uv32bit, param[1].uv32bit, (GLvoid **)param[2].ptr);
}

void STUB_glGetNamedBufferSubDataEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glGetNamedBufferSubDataEXT( GLuint, GLintptr, GLsizeiptr, GLvoid * )
    maxParam = 4;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_PARAM(v32bit,1);
    READ_PARAM(v32bit,2);
    READ_ARRAY_PARAM( 3, buffer0, TraceReader::TEXT_IGNORE);
    TR.skipLine();
    CHECK_USER_CALL(glGetNamedBufferSubDataEXT)
        UCT.glGetNamedBufferSubDataEXT(param[0].uv32bit, param[1].v32bit, param[2].v32bit, (GLvoid *)param[3].ptr);
    CHECK_GL_CALL(glGetNamedBufferSubDataEXT)
        JT.glGetNamedBufferSubDataEXT(param[0].uv32bit, param[1].v32bit, param[2].v32bit, (GLvoid *)param[3].ptr);
}

void STUB_glGetNamedFramebufferAttachmentParameterivEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glGetNamedFramebufferAttachmentParameterivEXT( GLuint, GLenum, GLenum, GLint * )
    maxParam = 4;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_ENUM_PARAM(2);
    READ_ARRAY_PARAM( 3, buffer0, TraceReader::TEXT_INT);
    TR.skipLine();
    CHECK_USER_CALL(glGetNamedFramebufferAttachmentParameterivEXT)
        UCT.glGetNamedFramebufferAttachmentParameterivEXT(param[0].uv32bit, param[1].uv32bit, param[2].uv32bit, (GLint *)param[3].ptr);
    CHECK_GL_CALL(glGetNamedFramebufferAttachmentParameterivEXT)
        JT.glGetNamedFramebufferAttachmentParameterivEXT(param[0].uv32bit, param[1].uv32bit, param[2].uv32bit, (GLint *)param[3].ptr);
}

void STUB_glGetNamedProgramLocalParameterIivEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glGetNamedProgramLocalParameterIivEXT( GLuint, GLenum, GLuint, GLint * )
    maxParam = 4;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_ENUM_PARAM(2);
    READ_ARRAY_PARAM( 3, buffer0, TraceReader::TEXT_INT);
    TR.skipLine();
    CHECK_USER_CALL(glGetNamedProgramLocalParameterIivEXT)
        UCT.glGetNamedProgramLocalParameterIivEXT(param[0].uv32bit, param[1].uv32bit, param[2].uv32bit, (GLint *)param[3].ptr);
    CHECK_GL_CALL(glGetNamedProgramLocalParameterIivEXT)
        JT.glGetNamedProgramLocalParameterIivEXT(param[0].uv32bit, param[1].uv32bit, param[2].uv32bit, (GLint *)param[3].ptr);
}

void STUB_glGetNamedProgramLocalParameterIuivEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glGetNamedProgramLocalParameterIuivEXT( GLuint, GLenum, GLuint, GLuint * )
    maxParam = 4;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_ENUM_PARAM(2);
    READ_ARRAY_PARAM( 3, buffer0, TraceReader::TEXT_INT);
    TR.skipLine();
    CHECK_USER_CALL(glGetNamedProgramLocalParameterIuivEXT)
        UCT.glGetNamedProgramLocalParameterIuivEXT(param[0].uv32bit, param[1].uv32bit, param[2].uv32bit, (GLuint *)param[3].ptr);
    CHECK_GL_CALL(glGetNamedProgramLocalParameterIuivEXT)
        JT.glGetNamedProgramLocalParameterIuivEXT(param[0].uv32bit, param[1].uv32bit, param[2].uv32bit, (GLuint *)param[3].ptr);
}

void STUB_glGetNamedProgramLocalParameterdvEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glGetNamedProgramLocalParameterdvEXT( GLuint, GLenum, GLuint, GLdouble * )
    maxParam = 4;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_ENUM_PARAM(2);
    READ_ARRAY_PARAM( 3, buffer0, TraceReader::TEXT_DOUBLE);
    TR.skipLine();
    CHECK_USER_CALL(glGetNamedProgramLocalParameterdvEXT)
        UCT.glGetNamedProgramLocalParameterdvEXT(param[0].uv32bit, param[1].uv32bit, param[2].uv32bit, (GLdouble *)param[3].ptr);
    CHECK_GL_CALL(glGetNamedProgramLocalParameterdvEXT)
        JT.glGetNamedProgramLocalParameterdvEXT(param[0].uv32bit, param[1].uv32bit, param[2].uv32bit, (GLdouble *)param[3].ptr);
}

void STUB_glGetNamedProgramLocalParameterfvEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glGetNamedProgramLocalParameterfvEXT( GLuint, GLenum, GLuint, GLfloat * )
    maxParam = 4;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_ENUM_PARAM(2);
    READ_ARRAY_PARAM( 3, buffer0, TraceReader::TEXT_FLOAT);
    TR.skipLine();
    CHECK_USER_CALL(glGetNamedProgramLocalParameterfvEXT)
        UCT.glGetNamedProgramLocalParameterfvEXT(param[0].uv32bit, param[1].uv32bit, param[2].uv32bit, (GLfloat *)param[3].ptr);
    CHECK_GL_CALL(glGetNamedProgramLocalParameterfvEXT)
        JT.glGetNamedProgramLocalParameterfvEXT(param[0].uv32bit, param[1].uv32bit, param[2].uv32bit, (GLfloat *)param[3].ptr);
}

void STUB_glGetNamedProgramStringEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glGetNamedProgramStringEXT( GLuint, GLenum, GLenum, GLvoid * )
    maxParam = 4;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_ENUM_PARAM(2);
    READ_ARRAY_PARAM( 3, buffer0, TraceReader::TEXT_IGNORE);
    TR.skipLine();
    CHECK_USER_CALL(glGetNamedProgramStringEXT)
        UCT.glGetNamedProgramStringEXT(param[0].uv32bit, param[1].uv32bit, param[2].uv32bit, (GLvoid *)param[3].ptr);
    CHECK_GL_CALL(glGetNamedProgramStringEXT)
        JT.glGetNamedProgramStringEXT(param[0].uv32bit, param[1].uv32bit, param[2].uv32bit, (GLvoid *)param[3].ptr);
}

void STUB_glGetNamedProgramivEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glGetNamedProgramivEXT( GLuint, GLenum, GLenum, GLint * )
    maxParam = 4;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_ENUM_PARAM(2);
    READ_ARRAY_PARAM( 3, buffer0, TraceReader::TEXT_INT);
    TR.skipLine();
    CHECK_USER_CALL(glGetNamedProgramivEXT)
        UCT.glGetNamedProgramivEXT(param[0].uv32bit, param[1].uv32bit, param[2].uv32bit, (GLint *)param[3].ptr);
    CHECK_GL_CALL(glGetNamedProgramivEXT)
        JT.glGetNamedProgramivEXT(param[0].uv32bit, param[1].uv32bit, param[2].uv32bit, (GLint *)param[3].ptr);
}

void STUB_glGetNamedRenderbufferParameterivEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glGetNamedRenderbufferParameterivEXT( GLuint, GLenum, GLint * )
    maxParam = 3;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_ARRAY_PARAM( 2, buffer0, TraceReader::TEXT_INT);
    TR.skipLine();
    CHECK_USER_CALL(glGetNamedRenderbufferParameterivEXT)
        UCT.glGetNamedRenderbufferParameterivEXT(param[0].uv32bit, param[1].uv32bit, (GLint *)param[2].ptr);
    CHECK_GL_CALL(glGetNamedRenderbufferParameterivEXT)
        JT.glGetNamedRenderbufferParameterivEXT(param[0].uv32bit, param[1].uv32bit, (GLint *)param[2].ptr);
}

void STUB_glGetObjectBufferfvATI( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glGetObjectBufferfvATI( GLuint, GLenum, GLfloat * )
    maxParam = 3;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_ARRAY_PARAM( 2, buffer0, TraceReader::TEXT_FLOAT);
    TR.skipLine();
    CHECK_USER_CALL(glGetObjectBufferfvATI)
        UCT.glGetObjectBufferfvATI(param[0].uv32bit, param[1].uv32bit, (GLfloat *)param[2].ptr);
    CHECK_GL_CALL(glGetObjectBufferfvATI)
        JT.glGetObjectBufferfvATI(param[0].uv32bit, param[1].uv32bit, (GLfloat *)param[2].ptr);
}

void STUB_glGetObjectBufferivATI( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glGetObjectBufferivATI( GLuint, GLenum, GLint * )
    maxParam = 3;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_ARRAY_PARAM( 2, buffer0, TraceReader::TEXT_INT);
    TR.skipLine();
    CHECK_USER_CALL(glGetObjectBufferivATI)
        UCT.glGetObjectBufferivATI(param[0].uv32bit, param[1].uv32bit, (GLint *)param[2].ptr);
    CHECK_GL_CALL(glGetObjectBufferivATI)
        JT.glGetObjectBufferivATI(param[0].uv32bit, param[1].uv32bit, (GLint *)param[2].ptr);
}

void STUB_glGetObjectParameterfvARB( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glGetObjectParameterfvARB( GLhandleARB, GLenum, GLfloat * )
    maxParam = 3;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_ARRAY_PARAM( 2, buffer0, TraceReader::TEXT_FLOAT);
    TR.skipLine();
    CHECK_USER_CALL(glGetObjectParameterfvARB)
        UCT.glGetObjectParameterfvARB(param[0].uv32bit, param[1].uv32bit, (GLfloat *)param[2].ptr);
    CHECK_GL_CALL(glGetObjectParameterfvARB)
        JT.glGetObjectParameterfvARB(param[0].uv32bit, param[1].uv32bit, (GLfloat *)param[2].ptr);
}

void STUB_glGetObjectParameterivARB( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glGetObjectParameterivARB( GLhandleARB, GLenum, GLint * )
    maxParam = 3;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_ARRAY_PARAM( 2, buffer0, TraceReader::TEXT_INT);
    TR.skipLine();
    CHECK_USER_CALL(glGetObjectParameterivARB)
        UCT.glGetObjectParameterivARB(param[0].uv32bit, param[1].uv32bit, (GLint *)param[2].ptr);
    CHECK_GL_CALL(glGetObjectParameterivARB)
        JT.glGetObjectParameterivARB(param[0].uv32bit, param[1].uv32bit, (GLint *)param[2].ptr);
}

void STUB_glGetOcclusionQueryivNV( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glGetOcclusionQueryivNV( GLuint, GLenum, GLint * )
    maxParam = 3;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_ARRAY_PARAM( 2, buffer0, TraceReader::TEXT_INT);
    TR.skipLine();
    CHECK_USER_CALL(glGetOcclusionQueryivNV)
        UCT.glGetOcclusionQueryivNV(param[0].uv32bit, param[1].uv32bit, (GLint *)param[2].ptr);
    CHECK_GL_CALL(glGetOcclusionQueryivNV)
        JT.glGetOcclusionQueryivNV(param[0].uv32bit, param[1].uv32bit, (GLint *)param[2].ptr);
}

void STUB_glGetOcclusionQueryuivNV( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glGetOcclusionQueryuivNV( GLuint, GLenum, GLuint * )
    maxParam = 3;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_ARRAY_PARAM( 2, buffer0, TraceReader::TEXT_INT);
    TR.skipLine();
    CHECK_USER_CALL(glGetOcclusionQueryuivNV)
        UCT.glGetOcclusionQueryuivNV(param[0].uv32bit, param[1].uv32bit, (GLuint *)param[2].ptr);
    CHECK_GL_CALL(glGetOcclusionQueryuivNV)
        JT.glGetOcclusionQueryuivNV(param[0].uv32bit, param[1].uv32bit, (GLuint *)param[2].ptr);
}

void STUB_glGetPerfMonitorCounterDataAMD( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glGetPerfMonitorCounterDataAMD( GLuint, GLenum, GLsizei, GLuint *, GLint * )
    maxParam = 5;
    char buffer0[16*4096];
    char buffer1[16*4096];
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_PARAM(v32bit,2);
    READ_ARRAY_PARAM( 3, buffer0, TraceReader::TEXT_INT);
    READ_ARRAY_PARAM( 4, buffer1, TraceReader::TEXT_INT);
    TR.skipLine();
    CHECK_USER_CALL(glGetPerfMonitorCounterDataAMD)
        UCT.glGetPerfMonitorCounterDataAMD(param[0].uv32bit, param[1].uv32bit, param[2].v32bit, (GLuint *)param[3].ptr, (GLint *)param[4].ptr);
    CHECK_GL_CALL(glGetPerfMonitorCounterDataAMD)
        JT.glGetPerfMonitorCounterDataAMD(param[0].uv32bit, param[1].uv32bit, param[2].v32bit, (GLuint *)param[3].ptr, (GLint *)param[4].ptr);
}

void STUB_glGetPerfMonitorCounterInfoAMD( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glGetPerfMonitorCounterInfoAMD( GLuint, GLuint, GLenum, void * )
    maxParam = 4;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_ENUM_PARAM(2);
    READ_ARRAY_PARAM( 3, buffer0, TraceReader::TEXT_IGNORE);
    TR.skipLine();
    CHECK_USER_CALL(glGetPerfMonitorCounterInfoAMD)
        UCT.glGetPerfMonitorCounterInfoAMD(param[0].uv32bit, param[1].uv32bit, param[2].uv32bit, (void *)param[3].ptr);
    CHECK_GL_CALL(glGetPerfMonitorCounterInfoAMD)
        JT.glGetPerfMonitorCounterInfoAMD(param[0].uv32bit, param[1].uv32bit, param[2].uv32bit, (void *)param[3].ptr);
}

void STUB_glGetPerfMonitorCounterStringAMD( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glGetPerfMonitorCounterStringAMD( GLuint, GLuint, GLsizei, GLsizei *, GLchar * )
    // Call not playable
    TR.skipCall();
}

void STUB_glGetPerfMonitorCountersAMD( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glGetPerfMonitorCountersAMD( GLuint, GLint *, GLint *, GLsizei, GLuint * )
    maxParam = 5;
    char buffer0[16*4096];
    char buffer1[16*4096];
    char buffer2[16*4096];
    READ_ENUM_PARAM(0);
    READ_ARRAY_PARAM( 1, buffer0, TraceReader::TEXT_INT);
    READ_ARRAY_PARAM( 2, buffer1, TraceReader::TEXT_INT);
    READ_PARAM(v32bit,3);
    READ_ARRAY_PARAM( 4, buffer2, TraceReader::TEXT_INT);
    TR.skipLine();
    CHECK_USER_CALL(glGetPerfMonitorCountersAMD)
        UCT.glGetPerfMonitorCountersAMD(param[0].uv32bit, (GLint *)param[1].ptr, (GLint *)param[2].ptr, param[3].v32bit, (GLuint *)param[4].ptr);
    CHECK_GL_CALL(glGetPerfMonitorCountersAMD)
        JT.glGetPerfMonitorCountersAMD(param[0].uv32bit, (GLint *)param[1].ptr, (GLint *)param[2].ptr, param[3].v32bit, (GLuint *)param[4].ptr);
}

void STUB_glGetPerfMonitorGroupStringAMD( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glGetPerfMonitorGroupStringAMD( GLuint, GLsizei, GLsizei *, GLchar * )
    // Call not playable
    TR.skipCall();
}

void STUB_glGetPerfMonitorGroupsAMD( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glGetPerfMonitorGroupsAMD( GLint *, GLsizei, GLuint * )
    maxParam = 3;
    char buffer0[16*4096];
    char buffer1[16*4096];
    READ_ARRAY_PARAM( 0, buffer0, TraceReader::TEXT_INT);
    READ_PARAM(v32bit,1);
    READ_ARRAY_PARAM( 2, buffer1, TraceReader::TEXT_INT);
    TR.skipLine();
    CHECK_USER_CALL(glGetPerfMonitorGroupsAMD)
        UCT.glGetPerfMonitorGroupsAMD((GLint *)param[0].ptr, param[1].v32bit, (GLuint *)param[2].ptr);
    CHECK_GL_CALL(glGetPerfMonitorGroupsAMD)
        JT.glGetPerfMonitorGroupsAMD((GLint *)param[0].ptr, param[1].v32bit, (GLuint *)param[2].ptr);
}

void STUB_glGetPixelMapfv( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glGetPixelMapfv( GLenum map, GLfloat *values )
    maxParam = 2;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ARRAY_PARAM( 1, buffer0, TraceReader::TEXT_FLOAT);
    TR.skipLine();
    CHECK_USER_CALL(glGetPixelMapfv)
        UCT.glGetPixelMapfv(param[0].uv32bit, (GLfloat *)param[1].ptr);
    CHECK_GL_CALL(glGetPixelMapfv)
        JT.glGetPixelMapfv(param[0].uv32bit, (GLfloat *)param[1].ptr);
}

void STUB_glGetPixelMapuiv( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glGetPixelMapuiv( GLenum map, GLuint *values )
    maxParam = 2;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ARRAY_PARAM( 1, buffer0, TraceReader::TEXT_INT);
    TR.skipLine();
    CHECK_USER_CALL(glGetPixelMapuiv)
        UCT.glGetPixelMapuiv(param[0].uv32bit, (GLuint *)param[1].ptr);
    CHECK_GL_CALL(glGetPixelMapuiv)
        JT.glGetPixelMapuiv(param[0].uv32bit, (GLuint *)param[1].ptr);
}

void STUB_glGetPixelMapusv( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glGetPixelMapusv( GLenum map, GLushort *values )
    maxParam = 2;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ARRAY_PARAM( 1, buffer0, TraceReader::TEXT_SHORT);
    TR.skipLine();
    CHECK_USER_CALL(glGetPixelMapusv)
        UCT.glGetPixelMapusv(param[0].uv32bit, (GLushort *)param[1].ptr);
    CHECK_GL_CALL(glGetPixelMapusv)
        JT.glGetPixelMapusv(param[0].uv32bit, (GLushort *)param[1].ptr);
}

void STUB_glGetPixelTexGenParameterfvSGIS( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glGetPixelTexGenParameterfvSGIS( GLenum, GLfloat * )
    maxParam = 2;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ARRAY_PARAM( 1, buffer0, TraceReader::TEXT_FLOAT);
    TR.skipLine();
    CHECK_USER_CALL(glGetPixelTexGenParameterfvSGIS)
        UCT.glGetPixelTexGenParameterfvSGIS(param[0].uv32bit, (GLfloat *)param[1].ptr);
    CHECK_GL_CALL(glGetPixelTexGenParameterfvSGIS)
        JT.glGetPixelTexGenParameterfvSGIS(param[0].uv32bit, (GLfloat *)param[1].ptr);
}

void STUB_glGetPixelTexGenParameterivSGIS( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glGetPixelTexGenParameterivSGIS( GLenum, GLint * )
    maxParam = 2;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ARRAY_PARAM( 1, buffer0, TraceReader::TEXT_INT);
    TR.skipLine();
    CHECK_USER_CALL(glGetPixelTexGenParameterivSGIS)
        UCT.glGetPixelTexGenParameterivSGIS(param[0].uv32bit, (GLint *)param[1].ptr);
    CHECK_GL_CALL(glGetPixelTexGenParameterivSGIS)
        JT.glGetPixelTexGenParameterivSGIS(param[0].uv32bit, (GLint *)param[1].ptr);
}

void STUB_glGetPointerIndexedvEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glGetPointerIndexedvEXT( GLenum, GLuint, GLvoid ** )
    maxParam = 3;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_ARRAY_PARAM( 2, buffer0, TraceReader::TEXT_IGNORE);
    TR.skipLine();
    CHECK_USER_CALL(glGetPointerIndexedvEXT)
        UCT.glGetPointerIndexedvEXT(param[0].uv32bit, param[1].uv32bit, (GLvoid **)param[2].ptr);
    CHECK_GL_CALL(glGetPointerIndexedvEXT)
        JT.glGetPointerIndexedvEXT(param[0].uv32bit, param[1].uv32bit, (GLvoid **)param[2].ptr);
}

void STUB_glGetPointerv( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glGetPointerv( GLenum pname, GLvoid **params )
    maxParam = 2;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ARRAY_PARAM( 1, buffer0, TraceReader::TEXT_IGNORE);
    TR.skipLine();
    CHECK_USER_CALL(glGetPointerv)
        UCT.glGetPointerv(param[0].uv32bit, (GLvoid **)param[1].ptr);
    CHECK_GL_CALL(glGetPointerv)
        JT.glGetPointerv(param[0].uv32bit, (GLvoid **)param[1].ptr);
}

void STUB_glGetPointervEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glGetPointervEXT( GLenum, GLvoid ** )
    maxParam = 2;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ARRAY_PARAM( 1, buffer0, TraceReader::TEXT_IGNORE);
    TR.skipLine();
    CHECK_USER_CALL(glGetPointervEXT)
        UCT.glGetPointervEXT(param[0].uv32bit, (GLvoid **)param[1].ptr);
    CHECK_GL_CALL(glGetPointervEXT)
        JT.glGetPointervEXT(param[0].uv32bit, (GLvoid **)param[1].ptr);
}

void STUB_glGetPolygonStipple( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glGetPolygonStipple( GLubyte *mask )
    maxParam = 1;
    char buffer0[16*4096];
    READ_ARRAY_PARAM( 0, buffer0, TraceReader::TEXT_BYTE);
    TR.skipLine();
    CHECK_USER_CALL(glGetPolygonStipple)
        UCT.glGetPolygonStipple((GLubyte *)param[0].ptr);
    CHECK_GL_CALL(glGetPolygonStipple)
        JT.glGetPolygonStipple((GLubyte *)param[0].ptr);
}

void STUB_glGetProgramEnvParameterIivNV( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glGetProgramEnvParameterIivNV( GLenum, GLuint, GLint * )
    maxParam = 3;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_ARRAY_PARAM( 2, buffer0, TraceReader::TEXT_INT);
    TR.skipLine();
    CHECK_USER_CALL(glGetProgramEnvParameterIivNV)
        UCT.glGetProgramEnvParameterIivNV(param[0].uv32bit, param[1].uv32bit, (GLint *)param[2].ptr);
    CHECK_GL_CALL(glGetProgramEnvParameterIivNV)
        JT.glGetProgramEnvParameterIivNV(param[0].uv32bit, param[1].uv32bit, (GLint *)param[2].ptr);
}

void STUB_glGetProgramEnvParameterIuivNV( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glGetProgramEnvParameterIuivNV( GLenum, GLuint, GLuint * )
    maxParam = 3;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_ARRAY_PARAM( 2, buffer0, TraceReader::TEXT_INT);
    TR.skipLine();
    CHECK_USER_CALL(glGetProgramEnvParameterIuivNV)
        UCT.glGetProgramEnvParameterIuivNV(param[0].uv32bit, param[1].uv32bit, (GLuint *)param[2].ptr);
    CHECK_GL_CALL(glGetProgramEnvParameterIuivNV)
        JT.glGetProgramEnvParameterIuivNV(param[0].uv32bit, param[1].uv32bit, (GLuint *)param[2].ptr);
}

void STUB_glGetProgramEnvParameterdvARB( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glGetProgramEnvParameterdvARB( GLenum, GLuint, GLdouble * )
    maxParam = 3;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_ARRAY_PARAM( 2, buffer0, TraceReader::TEXT_DOUBLE);
    TR.skipLine();
    CHECK_USER_CALL(glGetProgramEnvParameterdvARB)
        UCT.glGetProgramEnvParameterdvARB(param[0].uv32bit, param[1].uv32bit, (GLdouble *)param[2].ptr);
    CHECK_GL_CALL(glGetProgramEnvParameterdvARB)
        JT.glGetProgramEnvParameterdvARB(param[0].uv32bit, param[1].uv32bit, (GLdouble *)param[2].ptr);
}

void STUB_glGetProgramEnvParameterfvARB( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glGetProgramEnvParameterfvARB( GLenum, GLuint, GLfloat * )
    maxParam = 3;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_ARRAY_PARAM( 2, buffer0, TraceReader::TEXT_FLOAT);
    TR.skipLine();
    CHECK_USER_CALL(glGetProgramEnvParameterfvARB)
        UCT.glGetProgramEnvParameterfvARB(param[0].uv32bit, param[1].uv32bit, (GLfloat *)param[2].ptr);
    CHECK_GL_CALL(glGetProgramEnvParameterfvARB)
        JT.glGetProgramEnvParameterfvARB(param[0].uv32bit, param[1].uv32bit, (GLfloat *)param[2].ptr);
}

void STUB_glGetProgramInfoLog( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glGetProgramInfoLog( GLuint, GLsizei, GLsizei *, GLchar * )
    // Call not playable
    TR.skipCall();
}

void STUB_glGetProgramLocalParameterIivNV( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glGetProgramLocalParameterIivNV( GLenum, GLuint, GLint * )
    maxParam = 3;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_ARRAY_PARAM( 2, buffer0, TraceReader::TEXT_INT);
    TR.skipLine();
    CHECK_USER_CALL(glGetProgramLocalParameterIivNV)
        UCT.glGetProgramLocalParameterIivNV(param[0].uv32bit, param[1].uv32bit, (GLint *)param[2].ptr);
    CHECK_GL_CALL(glGetProgramLocalParameterIivNV)
        JT.glGetProgramLocalParameterIivNV(param[0].uv32bit, param[1].uv32bit, (GLint *)param[2].ptr);
}

void STUB_glGetProgramLocalParameterIuivNV( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glGetProgramLocalParameterIuivNV( GLenum, GLuint, GLuint * )
    maxParam = 3;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_ARRAY_PARAM( 2, buffer0, TraceReader::TEXT_INT);
    TR.skipLine();
    CHECK_USER_CALL(glGetProgramLocalParameterIuivNV)
        UCT.glGetProgramLocalParameterIuivNV(param[0].uv32bit, param[1].uv32bit, (GLuint *)param[2].ptr);
    CHECK_GL_CALL(glGetProgramLocalParameterIuivNV)
        JT.glGetProgramLocalParameterIuivNV(param[0].uv32bit, param[1].uv32bit, (GLuint *)param[2].ptr);
}

void STUB_glGetProgramLocalParameterdvARB( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glGetProgramLocalParameterdvARB( GLenum, GLuint, GLdouble * )
    maxParam = 3;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_ARRAY_PARAM( 2, buffer0, TraceReader::TEXT_DOUBLE);
    TR.skipLine();
    CHECK_USER_CALL(glGetProgramLocalParameterdvARB)
        UCT.glGetProgramLocalParameterdvARB(param[0].uv32bit, param[1].uv32bit, (GLdouble *)param[2].ptr);
    CHECK_GL_CALL(glGetProgramLocalParameterdvARB)
        JT.glGetProgramLocalParameterdvARB(param[0].uv32bit, param[1].uv32bit, (GLdouble *)param[2].ptr);
}

void STUB_glGetProgramLocalParameterfvARB( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glGetProgramLocalParameterfvARB( GLenum, GLuint, GLfloat * )
    maxParam = 3;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_ARRAY_PARAM( 2, buffer0, TraceReader::TEXT_FLOAT);
    TR.skipLine();
    CHECK_USER_CALL(glGetProgramLocalParameterfvARB)
        UCT.glGetProgramLocalParameterfvARB(param[0].uv32bit, param[1].uv32bit, (GLfloat *)param[2].ptr);
    CHECK_GL_CALL(glGetProgramLocalParameterfvARB)
        JT.glGetProgramLocalParameterfvARB(param[0].uv32bit, param[1].uv32bit, (GLfloat *)param[2].ptr);
}

void STUB_glGetProgramNamedParameterdvNV( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glGetProgramNamedParameterdvNV( GLuint, GLsizei, const GLubyte *, GLdouble * )
    maxParam = 4;
    char buffer0[16*4096];
    char buffer1[16*4096];
    READ_ENUM_PARAM(0);
    READ_PARAM(v32bit,1);
    READ_ARRAY_PARAM( 2, buffer0, TraceReader::TEXT_BYTE);
    READ_ARRAY_PARAM( 3, buffer1, TraceReader::TEXT_DOUBLE);
    TR.skipLine();
    CHECK_USER_CALL(glGetProgramNamedParameterdvNV)
        UCT.glGetProgramNamedParameterdvNV(param[0].uv32bit, param[1].v32bit, (const GLubyte *)param[2].ptr, (GLdouble *)param[3].ptr);
    CHECK_GL_CALL(glGetProgramNamedParameterdvNV)
        JT.glGetProgramNamedParameterdvNV(param[0].uv32bit, param[1].v32bit, (const GLubyte *)param[2].ptr, (GLdouble *)param[3].ptr);
}

void STUB_glGetProgramNamedParameterfvNV( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glGetProgramNamedParameterfvNV( GLuint, GLsizei, const GLubyte *, GLfloat * )
    maxParam = 4;
    char buffer0[16*4096];
    char buffer1[16*4096];
    READ_ENUM_PARAM(0);
    READ_PARAM(v32bit,1);
    READ_ARRAY_PARAM( 2, buffer0, TraceReader::TEXT_BYTE);
    READ_ARRAY_PARAM( 3, buffer1, TraceReader::TEXT_FLOAT);
    TR.skipLine();
    CHECK_USER_CALL(glGetProgramNamedParameterfvNV)
        UCT.glGetProgramNamedParameterfvNV(param[0].uv32bit, param[1].v32bit, (const GLubyte *)param[2].ptr, (GLfloat *)param[3].ptr);
    CHECK_GL_CALL(glGetProgramNamedParameterfvNV)
        JT.glGetProgramNamedParameterfvNV(param[0].uv32bit, param[1].v32bit, (const GLubyte *)param[2].ptr, (GLfloat *)param[3].ptr);
}

void STUB_glGetProgramParameterdvNV( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glGetProgramParameterdvNV( GLenum, GLuint, GLenum, GLdouble * )
    maxParam = 4;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_ENUM_PARAM(2);
    READ_ARRAY_PARAM( 3, buffer0, TraceReader::TEXT_DOUBLE);
    TR.skipLine();
    CHECK_USER_CALL(glGetProgramParameterdvNV)
        UCT.glGetProgramParameterdvNV(param[0].uv32bit, param[1].uv32bit, param[2].uv32bit, (GLdouble *)param[3].ptr);
    CHECK_GL_CALL(glGetProgramParameterdvNV)
        JT.glGetProgramParameterdvNV(param[0].uv32bit, param[1].uv32bit, param[2].uv32bit, (GLdouble *)param[3].ptr);
}

void STUB_glGetProgramParameterfvNV( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glGetProgramParameterfvNV( GLenum, GLuint, GLenum, GLfloat * )
    maxParam = 4;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_ENUM_PARAM(2);
    READ_ARRAY_PARAM( 3, buffer0, TraceReader::TEXT_FLOAT);
    TR.skipLine();
    CHECK_USER_CALL(glGetProgramParameterfvNV)
        UCT.glGetProgramParameterfvNV(param[0].uv32bit, param[1].uv32bit, param[2].uv32bit, (GLfloat *)param[3].ptr);
    CHECK_GL_CALL(glGetProgramParameterfvNV)
        JT.glGetProgramParameterfvNV(param[0].uv32bit, param[1].uv32bit, param[2].uv32bit, (GLfloat *)param[3].ptr);
}

void STUB_glGetProgramStringARB( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glGetProgramStringARB( GLenum, GLenum, GLvoid * )
    maxParam = 3;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_ARRAY_PARAM( 2, buffer0, TraceReader::TEXT_IGNORE);
    TR.skipLine();
    CHECK_USER_CALL(glGetProgramStringARB)
        UCT.glGetProgramStringARB(param[0].uv32bit, param[1].uv32bit, (GLvoid *)param[2].ptr);
    CHECK_GL_CALL(glGetProgramStringARB)
        JT.glGetProgramStringARB(param[0].uv32bit, param[1].uv32bit, (GLvoid *)param[2].ptr);
}

void STUB_glGetProgramStringNV( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glGetProgramStringNV( GLuint, GLenum, GLubyte * )
    maxParam = 3;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_ARRAY_PARAM( 2, buffer0, TraceReader::TEXT_BYTE);
    TR.skipLine();
    CHECK_USER_CALL(glGetProgramStringNV)
        UCT.glGetProgramStringNV(param[0].uv32bit, param[1].uv32bit, (GLubyte *)param[2].ptr);
    CHECK_GL_CALL(glGetProgramStringNV)
        JT.glGetProgramStringNV(param[0].uv32bit, param[1].uv32bit, (GLubyte *)param[2].ptr);
}

void STUB_glGetProgramiv( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glGetProgramiv( GLuint, GLenum, GLint * )
    maxParam = 3;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_ARRAY_PARAM( 2, buffer0, TraceReader::TEXT_INT);
    TR.skipLine();
    CHECK_USER_CALL(glGetProgramiv)
        UCT.glGetProgramiv(param[0].uv32bit, param[1].uv32bit, (GLint *)param[2].ptr);
    CHECK_GL_CALL(glGetProgramiv)
        JT.glGetProgramiv(param[0].uv32bit, param[1].uv32bit, (GLint *)param[2].ptr);
}

void STUB_glGetProgramivARB( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glGetProgramivARB( GLenum, GLenum, GLint * )
    maxParam = 3;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_ARRAY_PARAM( 2, buffer0, TraceReader::TEXT_INT);
    TR.skipLine();
    CHECK_USER_CALL(glGetProgramivARB)
        UCT.glGetProgramivARB(param[0].uv32bit, param[1].uv32bit, (GLint *)param[2].ptr);
    CHECK_GL_CALL(glGetProgramivARB)
        JT.glGetProgramivARB(param[0].uv32bit, param[1].uv32bit, (GLint *)param[2].ptr);
}

void STUB_glGetProgramivNV( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glGetProgramivNV( GLuint, GLenum, GLint * )
    maxParam = 3;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_ARRAY_PARAM( 2, buffer0, TraceReader::TEXT_INT);
    TR.skipLine();
    CHECK_USER_CALL(glGetProgramivNV)
        UCT.glGetProgramivNV(param[0].uv32bit, param[1].uv32bit, (GLint *)param[2].ptr);
    CHECK_GL_CALL(glGetProgramivNV)
        JT.glGetProgramivNV(param[0].uv32bit, param[1].uv32bit, (GLint *)param[2].ptr);
}

void STUB_glGetQueryObjecti64vEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glGetQueryObjecti64vEXT( GLuint, GLenum, GLint64EXT * )
    // Call not playable
    TR.skipCall();
}

void STUB_glGetQueryObjectiv( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glGetQueryObjectiv( GLuint, GLenum, GLint * )
    maxParam = 3;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_ARRAY_PARAM( 2, buffer0, TraceReader::TEXT_INT);
    TR.skipLine();
    CHECK_USER_CALL(glGetQueryObjectiv)
        UCT.glGetQueryObjectiv(param[0].uv32bit, param[1].uv32bit, (GLint *)param[2].ptr);
    CHECK_GL_CALL(glGetQueryObjectiv)
        JT.glGetQueryObjectiv(param[0].uv32bit, param[1].uv32bit, (GLint *)param[2].ptr);
}

void STUB_glGetQueryObjectivARB( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glGetQueryObjectivARB( GLuint, GLenum, GLint * )
    maxParam = 3;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_ARRAY_PARAM( 2, buffer0, TraceReader::TEXT_INT);
    TR.skipLine();
    CHECK_USER_CALL(glGetQueryObjectivARB)
        UCT.glGetQueryObjectivARB(param[0].uv32bit, param[1].uv32bit, (GLint *)param[2].ptr);
    CHECK_GL_CALL(glGetQueryObjectivARB)
        JT.glGetQueryObjectivARB(param[0].uv32bit, param[1].uv32bit, (GLint *)param[2].ptr);
}

void STUB_glGetQueryObjectui64vEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glGetQueryObjectui64vEXT( GLuint, GLenum, GLuint64EXT * )
    // Call not playable
    TR.skipCall();
}

void STUB_glGetQueryObjectuiv( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glGetQueryObjectuiv( GLuint, GLenum, GLuint * )
    maxParam = 3;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_ARRAY_PARAM( 2, buffer0, TraceReader::TEXT_INT);
    TR.skipLine();
    CHECK_USER_CALL(glGetQueryObjectuiv)
        UCT.glGetQueryObjectuiv(param[0].uv32bit, param[1].uv32bit, (GLuint *)param[2].ptr);
    CHECK_GL_CALL(glGetQueryObjectuiv)
        JT.glGetQueryObjectuiv(param[0].uv32bit, param[1].uv32bit, (GLuint *)param[2].ptr);
}

void STUB_glGetQueryObjectuivARB( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glGetQueryObjectuivARB( GLuint, GLenum, GLuint * )
    maxParam = 3;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_ARRAY_PARAM( 2, buffer0, TraceReader::TEXT_INT);
    TR.skipLine();
    CHECK_USER_CALL(glGetQueryObjectuivARB)
        UCT.glGetQueryObjectuivARB(param[0].uv32bit, param[1].uv32bit, (GLuint *)param[2].ptr);
    CHECK_GL_CALL(glGetQueryObjectuivARB)
        JT.glGetQueryObjectuivARB(param[0].uv32bit, param[1].uv32bit, (GLuint *)param[2].ptr);
}

void STUB_glGetQueryiv( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glGetQueryiv( GLenum, GLenum, GLint * )
    maxParam = 3;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_ARRAY_PARAM( 2, buffer0, TraceReader::TEXT_INT);
    TR.skipLine();
    CHECK_USER_CALL(glGetQueryiv)
        UCT.glGetQueryiv(param[0].uv32bit, param[1].uv32bit, (GLint *)param[2].ptr);
    CHECK_GL_CALL(glGetQueryiv)
        JT.glGetQueryiv(param[0].uv32bit, param[1].uv32bit, (GLint *)param[2].ptr);
}

void STUB_glGetQueryivARB( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glGetQueryivARB( GLenum, GLenum, GLint * )
    maxParam = 3;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_ARRAY_PARAM( 2, buffer0, TraceReader::TEXT_INT);
    TR.skipLine();
    CHECK_USER_CALL(glGetQueryivARB)
        UCT.glGetQueryivARB(param[0].uv32bit, param[1].uv32bit, (GLint *)param[2].ptr);
    CHECK_GL_CALL(glGetQueryivARB)
        JT.glGetQueryivARB(param[0].uv32bit, param[1].uv32bit, (GLint *)param[2].ptr);
}

void STUB_glGetRenderbufferParameteriv( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glGetRenderbufferParameteriv( GLenum, GLenum, GLint * )
    maxParam = 3;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_ARRAY_PARAM( 2, buffer0, TraceReader::TEXT_INT);
    TR.skipLine();
    CHECK_USER_CALL(glGetRenderbufferParameteriv)
        UCT.glGetRenderbufferParameteriv(param[0].uv32bit, param[1].uv32bit, (GLint *)param[2].ptr);
    CHECK_GL_CALL(glGetRenderbufferParameteriv)
        JT.glGetRenderbufferParameteriv(param[0].uv32bit, param[1].uv32bit, (GLint *)param[2].ptr);
}

void STUB_glGetRenderbufferParameterivEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glGetRenderbufferParameterivEXT( GLenum, GLenum, GLint * )
    maxParam = 3;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_ARRAY_PARAM( 2, buffer0, TraceReader::TEXT_INT);
    TR.skipLine();
    CHECK_USER_CALL(glGetRenderbufferParameterivEXT)
        UCT.glGetRenderbufferParameterivEXT(param[0].uv32bit, param[1].uv32bit, (GLint *)param[2].ptr);
    CHECK_GL_CALL(glGetRenderbufferParameterivEXT)
        JT.glGetRenderbufferParameterivEXT(param[0].uv32bit, param[1].uv32bit, (GLint *)param[2].ptr);
}

void STUB_glGetSeparableFilter( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glGetSeparableFilter( GLenum target, GLenum format, GLenum type, GLvoid *row, GLvoid *column, GLvoid *span )
    maxParam = 6;
    char buffer0[16*4096];
    char buffer1[16*4096];
    char buffer2[16*4096];
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_ENUM_PARAM(2);
    READ_ARRAY_PARAM( 3, buffer0, TraceReader::TEXT_IGNORE);
    READ_ARRAY_PARAM( 4, buffer1, TraceReader::TEXT_IGNORE);
    READ_ARRAY_PARAM( 5, buffer2, TraceReader::TEXT_IGNORE);
    TR.skipLine();
    CHECK_USER_CALL(glGetSeparableFilter)
        UCT.glGetSeparableFilter(param[0].uv32bit, param[1].uv32bit, param[2].uv32bit, (GLvoid *)param[3].ptr, (GLvoid *)param[4].ptr, (GLvoid *)param[5].ptr);
    CHECK_GL_CALL(glGetSeparableFilter)
        JT.glGetSeparableFilter(param[0].uv32bit, param[1].uv32bit, param[2].uv32bit, (GLvoid *)param[3].ptr, (GLvoid *)param[4].ptr, (GLvoid *)param[5].ptr);
}

void STUB_glGetSeparableFilterEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glGetSeparableFilterEXT( GLenum, GLenum, GLenum, GLvoid *, GLvoid *, GLvoid * )
    maxParam = 6;
    char buffer0[16*4096];
    char buffer1[16*4096];
    char buffer2[16*4096];
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_ENUM_PARAM(2);
    READ_ARRAY_PARAM( 3, buffer0, TraceReader::TEXT_IGNORE);
    READ_ARRAY_PARAM( 4, buffer1, TraceReader::TEXT_IGNORE);
    READ_ARRAY_PARAM( 5, buffer2, TraceReader::TEXT_IGNORE);
    TR.skipLine();
    CHECK_USER_CALL(glGetSeparableFilterEXT)
        UCT.glGetSeparableFilterEXT(param[0].uv32bit, param[1].uv32bit, param[2].uv32bit, (GLvoid *)param[3].ptr, (GLvoid *)param[4].ptr, (GLvoid *)param[5].ptr);
    CHECK_GL_CALL(glGetSeparableFilterEXT)
        JT.glGetSeparableFilterEXT(param[0].uv32bit, param[1].uv32bit, param[2].uv32bit, (GLvoid *)param[3].ptr, (GLvoid *)param[4].ptr, (GLvoid *)param[5].ptr);
}

void STUB_glGetShaderInfoLog( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glGetShaderInfoLog( GLuint, GLsizei, GLsizei *, GLchar * )
    // Call not playable
    TR.skipCall();
}

void STUB_glGetShaderSource( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glGetShaderSource( GLuint, GLsizei, GLsizei *, GLchar * )
    // Call not playable
    TR.skipCall();
}

void STUB_glGetShaderSourceARB( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glGetShaderSourceARB( GLhandleARB, GLsizei, GLsizei *, GLcharARB * )
    maxParam = 4;
    char buffer0[16*4096];
    char buffer1[16*4096];
    READ_ENUM_PARAM(0);
    READ_PARAM(v32bit,1);
    READ_ARRAY_PARAM( 2, buffer0, TraceReader::TEXT_INT);
    READ_ARRAY_PARAM( 3, buffer1, TraceReader::TEXT_BYTE);
    TR.skipLine();
    CHECK_USER_CALL(glGetShaderSourceARB)
        UCT.glGetShaderSourceARB(param[0].uv32bit, param[1].v32bit, (GLsizei *)param[2].ptr, (GLcharARB *)param[3].ptr);
    CHECK_GL_CALL(glGetShaderSourceARB)
        JT.glGetShaderSourceARB(param[0].uv32bit, param[1].v32bit, (GLsizei *)param[2].ptr, (GLcharARB *)param[3].ptr);
}

void STUB_glGetShaderiv( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glGetShaderiv( GLuint, GLenum, GLint * )
    maxParam = 3;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_ARRAY_PARAM( 2, buffer0, TraceReader::TEXT_INT);
    TR.skipLine();
    CHECK_USER_CALL(glGetShaderiv)
        UCT.glGetShaderiv(param[0].uv32bit, param[1].uv32bit, (GLint *)param[2].ptr);
    CHECK_GL_CALL(glGetShaderiv)
        JT.glGetShaderiv(param[0].uv32bit, param[1].uv32bit, (GLint *)param[2].ptr);
}

void STUB_glGetSharpenTexFuncSGIS( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glGetSharpenTexFuncSGIS( GLenum, GLfloat * )
    maxParam = 2;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ARRAY_PARAM( 1, buffer0, TraceReader::TEXT_FLOAT);
    TR.skipLine();
    CHECK_USER_CALL(glGetSharpenTexFuncSGIS)
        UCT.glGetSharpenTexFuncSGIS(param[0].uv32bit, (GLfloat *)param[1].ptr);
    CHECK_GL_CALL(glGetSharpenTexFuncSGIS)
        JT.glGetSharpenTexFuncSGIS(param[0].uv32bit, (GLfloat *)param[1].ptr);
}

void STUB_glGetString( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // const GLubyte *glGetString( GLenum name )
    maxParam = 1;
    READ_ENUM_PARAM(0);
    TR.skipResult();
    TR.skipLine();
    CHECK_USER_CALL(glGetString)
        UCT.glGetString(param[0].uv32bit);
    CHECK_GL_CALL(glGetString)
        JT.glGetString(param[0].uv32bit);
}

void STUB_glGetStringi( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // const GLubyte *glGetStringi( GLenum, GLuint )
    maxParam = 2;
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    TR.skipResult();
    TR.skipLine();
    CHECK_USER_CALL(glGetStringi)
        UCT.glGetStringi(param[0].uv32bit, param[1].uv32bit);
    CHECK_GL_CALL(glGetStringi)
        JT.glGetStringi(param[0].uv32bit, param[1].uv32bit);
}

void STUB_glGetTexBumpParameterfvATI( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glGetTexBumpParameterfvATI( GLenum, GLfloat * )
    maxParam = 2;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ARRAY_PARAM( 1, buffer0, TraceReader::TEXT_FLOAT);
    TR.skipLine();
    CHECK_USER_CALL(glGetTexBumpParameterfvATI)
        UCT.glGetTexBumpParameterfvATI(param[0].uv32bit, (GLfloat *)param[1].ptr);
    CHECK_GL_CALL(glGetTexBumpParameterfvATI)
        JT.glGetTexBumpParameterfvATI(param[0].uv32bit, (GLfloat *)param[1].ptr);
}

void STUB_glGetTexBumpParameterivATI( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glGetTexBumpParameterivATI( GLenum, GLint * )
    maxParam = 2;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ARRAY_PARAM( 1, buffer0, TraceReader::TEXT_INT);
    TR.skipLine();
    CHECK_USER_CALL(glGetTexBumpParameterivATI)
        UCT.glGetTexBumpParameterivATI(param[0].uv32bit, (GLint *)param[1].ptr);
    CHECK_GL_CALL(glGetTexBumpParameterivATI)
        JT.glGetTexBumpParameterivATI(param[0].uv32bit, (GLint *)param[1].ptr);
}

void STUB_glGetTexEnvfv( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glGetTexEnvfv( GLenum target, GLenum pname, GLfloat *params )
    maxParam = 3;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_ARRAY_PARAM( 2, buffer0, TraceReader::TEXT_FLOAT);
    TR.skipLine();
    CHECK_USER_CALL(glGetTexEnvfv)
        UCT.glGetTexEnvfv(param[0].uv32bit, param[1].uv32bit, (GLfloat *)param[2].ptr);
    CHECK_GL_CALL(glGetTexEnvfv)
        JT.glGetTexEnvfv(param[0].uv32bit, param[1].uv32bit, (GLfloat *)param[2].ptr);
}

void STUB_glGetTexEnviv( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glGetTexEnviv( GLenum target, GLenum pname, GLint *params )
    maxParam = 3;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_ARRAY_PARAM( 2, buffer0, TraceReader::TEXT_INT);
    TR.skipLine();
    CHECK_USER_CALL(glGetTexEnviv)
        UCT.glGetTexEnviv(param[0].uv32bit, param[1].uv32bit, (GLint *)param[2].ptr);
    CHECK_GL_CALL(glGetTexEnviv)
        JT.glGetTexEnviv(param[0].uv32bit, param[1].uv32bit, (GLint *)param[2].ptr);
}

void STUB_glGetTexFilterFuncSGIS( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glGetTexFilterFuncSGIS( GLenum, GLenum, GLfloat * )
    maxParam = 3;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_ARRAY_PARAM( 2, buffer0, TraceReader::TEXT_FLOAT);
    TR.skipLine();
    CHECK_USER_CALL(glGetTexFilterFuncSGIS)
        UCT.glGetTexFilterFuncSGIS(param[0].uv32bit, param[1].uv32bit, (GLfloat *)param[2].ptr);
    CHECK_GL_CALL(glGetTexFilterFuncSGIS)
        JT.glGetTexFilterFuncSGIS(param[0].uv32bit, param[1].uv32bit, (GLfloat *)param[2].ptr);
}

void STUB_glGetTexGendv( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glGetTexGendv( GLenum coord, GLenum pname, GLdouble *params )
    maxParam = 3;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_ARRAY_PARAM( 2, buffer0, TraceReader::TEXT_DOUBLE);
    TR.skipLine();
    CHECK_USER_CALL(glGetTexGendv)
        UCT.glGetTexGendv(param[0].uv32bit, param[1].uv32bit, (GLdouble *)param[2].ptr);
    CHECK_GL_CALL(glGetTexGendv)
        JT.glGetTexGendv(param[0].uv32bit, param[1].uv32bit, (GLdouble *)param[2].ptr);
}

void STUB_glGetTexGenfv( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glGetTexGenfv( GLenum coord, GLenum pname, GLfloat *params )
    maxParam = 3;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_ARRAY_PARAM( 2, buffer0, TraceReader::TEXT_FLOAT);
    TR.skipLine();
    CHECK_USER_CALL(glGetTexGenfv)
        UCT.glGetTexGenfv(param[0].uv32bit, param[1].uv32bit, (GLfloat *)param[2].ptr);
    CHECK_GL_CALL(glGetTexGenfv)
        JT.glGetTexGenfv(param[0].uv32bit, param[1].uv32bit, (GLfloat *)param[2].ptr);
}

void STUB_glGetTexGeniv( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glGetTexGeniv( GLenum coord, GLenum pname, GLint *params )
    maxParam = 3;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_ARRAY_PARAM( 2, buffer0, TraceReader::TEXT_INT);
    TR.skipLine();
    CHECK_USER_CALL(glGetTexGeniv)
        UCT.glGetTexGeniv(param[0].uv32bit, param[1].uv32bit, (GLint *)param[2].ptr);
    CHECK_GL_CALL(glGetTexGeniv)
        JT.glGetTexGeniv(param[0].uv32bit, param[1].uv32bit, (GLint *)param[2].ptr);
}

void STUB_glGetTexImage( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glGetTexImage( GLenum target, GLint level, GLenum format, GLenum type, GLvoid *pixels )
    maxParam = 5;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_PARAM(v32bit,1);
    READ_ENUM_PARAM(2);
    READ_ENUM_PARAM(3);
    READ_ARRAY_PARAM( 4, buffer0, TraceReader::TEXT_IGNORE);
    TR.skipLine();
    CHECK_USER_CALL(glGetTexImage)
        UCT.glGetTexImage(param[0].uv32bit, param[1].v32bit, param[2].uv32bit, param[3].uv32bit, (GLvoid *)param[4].ptr);
    CHECK_GL_CALL(glGetTexImage)
        JT.glGetTexImage(param[0].uv32bit, param[1].v32bit, param[2].uv32bit, param[3].uv32bit, (GLvoid *)param[4].ptr);
}

void STUB_glGetTexLevelParameterfv( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glGetTexLevelParameterfv( GLenum target, GLint level, GLenum pname, GLfloat *params )
    maxParam = 4;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_PARAM(v32bit,1);
    READ_ENUM_PARAM(2);
    READ_ARRAY_PARAM( 3, buffer0, TraceReader::TEXT_FLOAT);
    TR.skipLine();
    CHECK_USER_CALL(glGetTexLevelParameterfv)
        UCT.glGetTexLevelParameterfv(param[0].uv32bit, param[1].v32bit, param[2].uv32bit, (GLfloat *)param[3].ptr);
    CHECK_GL_CALL(glGetTexLevelParameterfv)
        JT.glGetTexLevelParameterfv(param[0].uv32bit, param[1].v32bit, param[2].uv32bit, (GLfloat *)param[3].ptr);
}

void STUB_glGetTexLevelParameteriv( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glGetTexLevelParameteriv( GLenum target, GLint level, GLenum pname, GLint *params )
    maxParam = 4;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_PARAM(v32bit,1);
    READ_ENUM_PARAM(2);
    READ_ARRAY_PARAM( 3, buffer0, TraceReader::TEXT_INT);
    TR.skipLine();
    CHECK_USER_CALL(glGetTexLevelParameteriv)
        UCT.glGetTexLevelParameteriv(param[0].uv32bit, param[1].v32bit, param[2].uv32bit, (GLint *)param[3].ptr);
    CHECK_GL_CALL(glGetTexLevelParameteriv)
        JT.glGetTexLevelParameteriv(param[0].uv32bit, param[1].v32bit, param[2].uv32bit, (GLint *)param[3].ptr);
}

void STUB_glGetTexParameterIiv( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glGetTexParameterIiv( GLenum, GLenum, GLint * )
    maxParam = 3;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_ARRAY_PARAM( 2, buffer0, TraceReader::TEXT_INT);
    TR.skipLine();
    CHECK_USER_CALL(glGetTexParameterIiv)
        UCT.glGetTexParameterIiv(param[0].uv32bit, param[1].uv32bit, (GLint *)param[2].ptr);
    CHECK_GL_CALL(glGetTexParameterIiv)
        JT.glGetTexParameterIiv(param[0].uv32bit, param[1].uv32bit, (GLint *)param[2].ptr);
}

void STUB_glGetTexParameterIivEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glGetTexParameterIivEXT( GLenum, GLenum, GLint * )
    maxParam = 3;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_ARRAY_PARAM( 2, buffer0, TraceReader::TEXT_INT);
    TR.skipLine();
    CHECK_USER_CALL(glGetTexParameterIivEXT)
        UCT.glGetTexParameterIivEXT(param[0].uv32bit, param[1].uv32bit, (GLint *)param[2].ptr);
    CHECK_GL_CALL(glGetTexParameterIivEXT)
        JT.glGetTexParameterIivEXT(param[0].uv32bit, param[1].uv32bit, (GLint *)param[2].ptr);
}

void STUB_glGetTexParameterIuiv( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glGetTexParameterIuiv( GLenum, GLenum, GLuint * )
    maxParam = 3;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_ARRAY_PARAM( 2, buffer0, TraceReader::TEXT_INT);
    TR.skipLine();
    CHECK_USER_CALL(glGetTexParameterIuiv)
        UCT.glGetTexParameterIuiv(param[0].uv32bit, param[1].uv32bit, (GLuint *)param[2].ptr);
    CHECK_GL_CALL(glGetTexParameterIuiv)
        JT.glGetTexParameterIuiv(param[0].uv32bit, param[1].uv32bit, (GLuint *)param[2].ptr);
}

void STUB_glGetTexParameterIuivEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glGetTexParameterIuivEXT( GLenum, GLenum, GLuint * )
    maxParam = 3;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_ARRAY_PARAM( 2, buffer0, TraceReader::TEXT_INT);
    TR.skipLine();
    CHECK_USER_CALL(glGetTexParameterIuivEXT)
        UCT.glGetTexParameterIuivEXT(param[0].uv32bit, param[1].uv32bit, (GLuint *)param[2].ptr);
    CHECK_GL_CALL(glGetTexParameterIuivEXT)
        JT.glGetTexParameterIuivEXT(param[0].uv32bit, param[1].uv32bit, (GLuint *)param[2].ptr);
}

void STUB_glGetTexParameterfv( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glGetTexParameterfv( GLenum target, GLenum pname, GLfloat *params )
    maxParam = 3;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_ARRAY_PARAM( 2, buffer0, TraceReader::TEXT_FLOAT);
    TR.skipLine();
    CHECK_USER_CALL(glGetTexParameterfv)
        UCT.glGetTexParameterfv(param[0].uv32bit, param[1].uv32bit, (GLfloat *)param[2].ptr);
    CHECK_GL_CALL(glGetTexParameterfv)
        JT.glGetTexParameterfv(param[0].uv32bit, param[1].uv32bit, (GLfloat *)param[2].ptr);
}

void STUB_glGetTexParameteriv( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glGetTexParameteriv( GLenum target, GLenum pname, GLint *params )
    maxParam = 3;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_ARRAY_PARAM( 2, buffer0, TraceReader::TEXT_INT);
    TR.skipLine();
    CHECK_USER_CALL(glGetTexParameteriv)
        UCT.glGetTexParameteriv(param[0].uv32bit, param[1].uv32bit, (GLint *)param[2].ptr);
    CHECK_GL_CALL(glGetTexParameteriv)
        JT.glGetTexParameteriv(param[0].uv32bit, param[1].uv32bit, (GLint *)param[2].ptr);
}

void STUB_glGetTextureImageEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glGetTextureImageEXT( GLuint, GLenum, GLint, GLenum, GLenum, GLvoid * )
    maxParam = 6;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_PARAM(v32bit,2);
    READ_ENUM_PARAM(3);
    READ_ENUM_PARAM(4);
    READ_ARRAY_PARAM( 5, buffer0, TraceReader::TEXT_IGNORE);
    TR.skipLine();
    CHECK_USER_CALL(glGetTextureImageEXT)
        UCT.glGetTextureImageEXT(param[0].uv32bit, param[1].uv32bit, param[2].v32bit, param[3].uv32bit, param[4].uv32bit, (GLvoid *)param[5].ptr);
    CHECK_GL_CALL(glGetTextureImageEXT)
        JT.glGetTextureImageEXT(param[0].uv32bit, param[1].uv32bit, param[2].v32bit, param[3].uv32bit, param[4].uv32bit, (GLvoid *)param[5].ptr);
}

void STUB_glGetTextureLevelParameterfvEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glGetTextureLevelParameterfvEXT( GLuint, GLenum, GLint, GLenum, GLfloat * )
    maxParam = 5;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_PARAM(v32bit,2);
    READ_ENUM_PARAM(3);
    READ_ARRAY_PARAM( 4, buffer0, TraceReader::TEXT_FLOAT);
    TR.skipLine();
    CHECK_USER_CALL(glGetTextureLevelParameterfvEXT)
        UCT.glGetTextureLevelParameterfvEXT(param[0].uv32bit, param[1].uv32bit, param[2].v32bit, param[3].uv32bit, (GLfloat *)param[4].ptr);
    CHECK_GL_CALL(glGetTextureLevelParameterfvEXT)
        JT.glGetTextureLevelParameterfvEXT(param[0].uv32bit, param[1].uv32bit, param[2].v32bit, param[3].uv32bit, (GLfloat *)param[4].ptr);
}

void STUB_glGetTextureLevelParameterivEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glGetTextureLevelParameterivEXT( GLuint, GLenum, GLint, GLenum, GLint * )
    maxParam = 5;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_PARAM(v32bit,2);
    READ_ENUM_PARAM(3);
    READ_ARRAY_PARAM( 4, buffer0, TraceReader::TEXT_INT);
    TR.skipLine();
    CHECK_USER_CALL(glGetTextureLevelParameterivEXT)
        UCT.glGetTextureLevelParameterivEXT(param[0].uv32bit, param[1].uv32bit, param[2].v32bit, param[3].uv32bit, (GLint *)param[4].ptr);
    CHECK_GL_CALL(glGetTextureLevelParameterivEXT)
        JT.glGetTextureLevelParameterivEXT(param[0].uv32bit, param[1].uv32bit, param[2].v32bit, param[3].uv32bit, (GLint *)param[4].ptr);
}

void STUB_glGetTextureParameterIivEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glGetTextureParameterIivEXT( GLuint, GLenum, GLenum, GLint * )
    maxParam = 4;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_ENUM_PARAM(2);
    READ_ARRAY_PARAM( 3, buffer0, TraceReader::TEXT_INT);
    TR.skipLine();
    CHECK_USER_CALL(glGetTextureParameterIivEXT)
        UCT.glGetTextureParameterIivEXT(param[0].uv32bit, param[1].uv32bit, param[2].uv32bit, (GLint *)param[3].ptr);
    CHECK_GL_CALL(glGetTextureParameterIivEXT)
        JT.glGetTextureParameterIivEXT(param[0].uv32bit, param[1].uv32bit, param[2].uv32bit, (GLint *)param[3].ptr);
}

void STUB_glGetTextureParameterIuivEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glGetTextureParameterIuivEXT( GLuint, GLenum, GLenum, GLuint * )
    maxParam = 4;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_ENUM_PARAM(2);
    READ_ARRAY_PARAM( 3, buffer0, TraceReader::TEXT_INT);
    TR.skipLine();
    CHECK_USER_CALL(glGetTextureParameterIuivEXT)
        UCT.glGetTextureParameterIuivEXT(param[0].uv32bit, param[1].uv32bit, param[2].uv32bit, (GLuint *)param[3].ptr);
    CHECK_GL_CALL(glGetTextureParameterIuivEXT)
        JT.glGetTextureParameterIuivEXT(param[0].uv32bit, param[1].uv32bit, param[2].uv32bit, (GLuint *)param[3].ptr);
}

void STUB_glGetTextureParameterfvEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glGetTextureParameterfvEXT( GLuint, GLenum, GLenum, GLfloat * )
    maxParam = 4;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_ENUM_PARAM(2);
    READ_ARRAY_PARAM( 3, buffer0, TraceReader::TEXT_FLOAT);
    TR.skipLine();
    CHECK_USER_CALL(glGetTextureParameterfvEXT)
        UCT.glGetTextureParameterfvEXT(param[0].uv32bit, param[1].uv32bit, param[2].uv32bit, (GLfloat *)param[3].ptr);
    CHECK_GL_CALL(glGetTextureParameterfvEXT)
        JT.glGetTextureParameterfvEXT(param[0].uv32bit, param[1].uv32bit, param[2].uv32bit, (GLfloat *)param[3].ptr);
}

void STUB_glGetTextureParameterivEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glGetTextureParameterivEXT( GLuint, GLenum, GLenum, GLint * )
    maxParam = 4;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_ENUM_PARAM(2);
    READ_ARRAY_PARAM( 3, buffer0, TraceReader::TEXT_INT);
    TR.skipLine();
    CHECK_USER_CALL(glGetTextureParameterivEXT)
        UCT.glGetTextureParameterivEXT(param[0].uv32bit, param[1].uv32bit, param[2].uv32bit, (GLint *)param[3].ptr);
    CHECK_GL_CALL(glGetTextureParameterivEXT)
        JT.glGetTextureParameterivEXT(param[0].uv32bit, param[1].uv32bit, param[2].uv32bit, (GLint *)param[3].ptr);
}

void STUB_glGetTrackMatrixivNV( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glGetTrackMatrixivNV( GLenum, GLuint, GLenum, GLint * )
    maxParam = 4;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_ENUM_PARAM(2);
    READ_ARRAY_PARAM( 3, buffer0, TraceReader::TEXT_INT);
    TR.skipLine();
    CHECK_USER_CALL(glGetTrackMatrixivNV)
        UCT.glGetTrackMatrixivNV(param[0].uv32bit, param[1].uv32bit, param[2].uv32bit, (GLint *)param[3].ptr);
    CHECK_GL_CALL(glGetTrackMatrixivNV)
        JT.glGetTrackMatrixivNV(param[0].uv32bit, param[1].uv32bit, param[2].uv32bit, (GLint *)param[3].ptr);
}

void STUB_glGetTransformFeedbackVarying( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glGetTransformFeedbackVarying( GLuint, GLuint, GLsizei, GLsizei *, GLsizei *, GLenum *, GLchar * )
    // Call not playable
    TR.skipCall();
}

void STUB_glGetTransformFeedbackVaryingEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glGetTransformFeedbackVaryingEXT( GLuint, GLuint, GLsizei, GLsizei *, GLsizei *, GLenum *, GLchar * )
    // Call not playable
    TR.skipCall();
}

void STUB_glGetTransformFeedbackVaryingNV( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glGetTransformFeedbackVaryingNV( GLuint, GLuint, GLint * )
    maxParam = 3;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_ARRAY_PARAM( 2, buffer0, TraceReader::TEXT_INT);
    TR.skipLine();
    CHECK_USER_CALL(glGetTransformFeedbackVaryingNV)
        UCT.glGetTransformFeedbackVaryingNV(param[0].uv32bit, param[1].uv32bit, (GLint *)param[2].ptr);
    CHECK_GL_CALL(glGetTransformFeedbackVaryingNV)
        JT.glGetTransformFeedbackVaryingNV(param[0].uv32bit, param[1].uv32bit, (GLint *)param[2].ptr);
}

void STUB_glGetUniformBlockIndex( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // GLuint glGetUniformBlockIndex( GLuint, const GLchar * )
    // Call not playable
    TR.skipCall();
}

void STUB_glGetUniformBufferSizeEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // GLint glGetUniformBufferSizeEXT( GLuint, GLint )
    maxParam = 2;
    READ_ENUM_PARAM(0);
    READ_PARAM(v32bit,1);
    TR.skipResult();
    TR.skipLine();
    CHECK_USER_CALL(glGetUniformBufferSizeEXT)
        UCT.glGetUniformBufferSizeEXT(param[0].uv32bit, param[1].v32bit);
    CHECK_GL_CALL(glGetUniformBufferSizeEXT)
        JT.glGetUniformBufferSizeEXT(param[0].uv32bit, param[1].v32bit);
}

void STUB_glGetUniformIndices( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glGetUniformIndices( GLuint, GLsizei, const GLchar **, GLuint * )
    // Call not playable
    TR.skipCall();
}

void STUB_glGetUniformLocation( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // GLint glGetUniformLocation( GLuint, const GLchar * )
    // Call not playable
    TR.skipCall();
}

void STUB_glGetUniformLocationARB( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // GLint glGetUniformLocationARB( GLhandleARB, const GLcharARB * )
    maxParam = 2;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ARRAY_PARAM( 1, buffer0, TraceReader::TEXT_BYTE);
    TR.skipResult();
    TR.skipLine();
    CHECK_USER_CALL(glGetUniformLocationARB)
        UCT.glGetUniformLocationARB(param[0].uv32bit, (const GLcharARB *)param[1].ptr);
    CHECK_GL_CALL(glGetUniformLocationARB)
        JT.glGetUniformLocationARB(param[0].uv32bit, (const GLcharARB *)param[1].ptr);
}

void STUB_glGetUniformOffsetEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // GLintptr glGetUniformOffsetEXT( GLuint, GLint )
    maxParam = 2;
    READ_ENUM_PARAM(0);
    READ_PARAM(v32bit,1);
    TR.skipResult();
    TR.skipLine();
    CHECK_USER_CALL(glGetUniformOffsetEXT)
        UCT.glGetUniformOffsetEXT(param[0].uv32bit, param[1].v32bit);
    CHECK_GL_CALL(glGetUniformOffsetEXT)
        JT.glGetUniformOffsetEXT(param[0].uv32bit, param[1].v32bit);
}

void STUB_glGetUniformfv( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glGetUniformfv( GLuint, GLint, GLfloat * )
    maxParam = 3;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_PARAM(v32bit,1);
    READ_ARRAY_PARAM( 2, buffer0, TraceReader::TEXT_FLOAT);
    TR.skipLine();
    CHECK_USER_CALL(glGetUniformfv)
        UCT.glGetUniformfv(param[0].uv32bit, param[1].v32bit, (GLfloat *)param[2].ptr);
    CHECK_GL_CALL(glGetUniformfv)
        JT.glGetUniformfv(param[0].uv32bit, param[1].v32bit, (GLfloat *)param[2].ptr);
}

void STUB_glGetUniformfvARB( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glGetUniformfvARB( GLhandleARB, GLint, GLfloat * )
    maxParam = 3;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_PARAM(v32bit,1);
    READ_ARRAY_PARAM( 2, buffer0, TraceReader::TEXT_FLOAT);
    TR.skipLine();
    CHECK_USER_CALL(glGetUniformfvARB)
        UCT.glGetUniformfvARB(param[0].uv32bit, param[1].v32bit, (GLfloat *)param[2].ptr);
    CHECK_GL_CALL(glGetUniformfvARB)
        JT.glGetUniformfvARB(param[0].uv32bit, param[1].v32bit, (GLfloat *)param[2].ptr);
}

void STUB_glGetUniformiv( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glGetUniformiv( GLuint, GLint, GLint * )
    maxParam = 3;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_PARAM(v32bit,1);
    READ_ARRAY_PARAM( 2, buffer0, TraceReader::TEXT_INT);
    TR.skipLine();
    CHECK_USER_CALL(glGetUniformiv)
        UCT.glGetUniformiv(param[0].uv32bit, param[1].v32bit, (GLint *)param[2].ptr);
    CHECK_GL_CALL(glGetUniformiv)
        JT.glGetUniformiv(param[0].uv32bit, param[1].v32bit, (GLint *)param[2].ptr);
}

void STUB_glGetUniformivARB( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glGetUniformivARB( GLhandleARB, GLint, GLint * )
    maxParam = 3;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_PARAM(v32bit,1);
    READ_ARRAY_PARAM( 2, buffer0, TraceReader::TEXT_INT);
    TR.skipLine();
    CHECK_USER_CALL(glGetUniformivARB)
        UCT.glGetUniformivARB(param[0].uv32bit, param[1].v32bit, (GLint *)param[2].ptr);
    CHECK_GL_CALL(glGetUniformivARB)
        JT.glGetUniformivARB(param[0].uv32bit, param[1].v32bit, (GLint *)param[2].ptr);
}

void STUB_glGetUniformuiv( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glGetUniformuiv( GLuint, GLint, GLuint * )
    maxParam = 3;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_PARAM(v32bit,1);
    READ_ARRAY_PARAM( 2, buffer0, TraceReader::TEXT_INT);
    TR.skipLine();
    CHECK_USER_CALL(glGetUniformuiv)
        UCT.glGetUniformuiv(param[0].uv32bit, param[1].v32bit, (GLuint *)param[2].ptr);
    CHECK_GL_CALL(glGetUniformuiv)
        JT.glGetUniformuiv(param[0].uv32bit, param[1].v32bit, (GLuint *)param[2].ptr);
}

void STUB_glGetUniformuivEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glGetUniformuivEXT( GLuint, GLint, GLuint * )
    maxParam = 3;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_PARAM(v32bit,1);
    READ_ARRAY_PARAM( 2, buffer0, TraceReader::TEXT_INT);
    TR.skipLine();
    CHECK_USER_CALL(glGetUniformuivEXT)
        UCT.glGetUniformuivEXT(param[0].uv32bit, param[1].v32bit, (GLuint *)param[2].ptr);
    CHECK_GL_CALL(glGetUniformuivEXT)
        JT.glGetUniformuivEXT(param[0].uv32bit, param[1].v32bit, (GLuint *)param[2].ptr);
}

void STUB_glGetVariantArrayObjectfvATI( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glGetVariantArrayObjectfvATI( GLuint, GLenum, GLfloat * )
    maxParam = 3;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_ARRAY_PARAM( 2, buffer0, TraceReader::TEXT_FLOAT);
    TR.skipLine();
    CHECK_USER_CALL(glGetVariantArrayObjectfvATI)
        UCT.glGetVariantArrayObjectfvATI(param[0].uv32bit, param[1].uv32bit, (GLfloat *)param[2].ptr);
    CHECK_GL_CALL(glGetVariantArrayObjectfvATI)
        JT.glGetVariantArrayObjectfvATI(param[0].uv32bit, param[1].uv32bit, (GLfloat *)param[2].ptr);
}

void STUB_glGetVariantArrayObjectivATI( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glGetVariantArrayObjectivATI( GLuint, GLenum, GLint * )
    maxParam = 3;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_ARRAY_PARAM( 2, buffer0, TraceReader::TEXT_INT);
    TR.skipLine();
    CHECK_USER_CALL(glGetVariantArrayObjectivATI)
        UCT.glGetVariantArrayObjectivATI(param[0].uv32bit, param[1].uv32bit, (GLint *)param[2].ptr);
    CHECK_GL_CALL(glGetVariantArrayObjectivATI)
        JT.glGetVariantArrayObjectivATI(param[0].uv32bit, param[1].uv32bit, (GLint *)param[2].ptr);
}

void STUB_glGetVariantBooleanvEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glGetVariantBooleanvEXT( GLuint, GLenum, GLboolean * )
    maxParam = 3;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_ARRAY_PARAM( 2, buffer0, TraceReader::TEXT_BYTE);
    TR.skipLine();
    CHECK_USER_CALL(glGetVariantBooleanvEXT)
        UCT.glGetVariantBooleanvEXT(param[0].uv32bit, param[1].uv32bit, (GLboolean *)param[2].ptr);
    CHECK_GL_CALL(glGetVariantBooleanvEXT)
        JT.glGetVariantBooleanvEXT(param[0].uv32bit, param[1].uv32bit, (GLboolean *)param[2].ptr);
}

void STUB_glGetVariantFloatvEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glGetVariantFloatvEXT( GLuint, GLenum, GLfloat * )
    maxParam = 3;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_ARRAY_PARAM( 2, buffer0, TraceReader::TEXT_FLOAT);
    TR.skipLine();
    CHECK_USER_CALL(glGetVariantFloatvEXT)
        UCT.glGetVariantFloatvEXT(param[0].uv32bit, param[1].uv32bit, (GLfloat *)param[2].ptr);
    CHECK_GL_CALL(glGetVariantFloatvEXT)
        JT.glGetVariantFloatvEXT(param[0].uv32bit, param[1].uv32bit, (GLfloat *)param[2].ptr);
}

void STUB_glGetVariantIntegervEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glGetVariantIntegervEXT( GLuint, GLenum, GLint * )
    maxParam = 3;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_ARRAY_PARAM( 2, buffer0, TraceReader::TEXT_INT);
    TR.skipLine();
    CHECK_USER_CALL(glGetVariantIntegervEXT)
        UCT.glGetVariantIntegervEXT(param[0].uv32bit, param[1].uv32bit, (GLint *)param[2].ptr);
    CHECK_GL_CALL(glGetVariantIntegervEXT)
        JT.glGetVariantIntegervEXT(param[0].uv32bit, param[1].uv32bit, (GLint *)param[2].ptr);
}

void STUB_glGetVariantPointervEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glGetVariantPointervEXT( GLuint, GLenum, GLvoid ** )
    maxParam = 3;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_ARRAY_PARAM( 2, buffer0, TraceReader::TEXT_IGNORE);
    TR.skipLine();
    CHECK_USER_CALL(glGetVariantPointervEXT)
        UCT.glGetVariantPointervEXT(param[0].uv32bit, param[1].uv32bit, (GLvoid **)param[2].ptr);
    CHECK_GL_CALL(glGetVariantPointervEXT)
        JT.glGetVariantPointervEXT(param[0].uv32bit, param[1].uv32bit, (GLvoid **)param[2].ptr);
}

void STUB_glGetVaryingLocationNV( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // GLint glGetVaryingLocationNV( GLuint, const GLchar * )
    // Call not playable
    TR.skipCall();
}

void STUB_glGetVertexAttribArrayObjectfvATI( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glGetVertexAttribArrayObjectfvATI( GLuint, GLenum, GLfloat * )
    maxParam = 3;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_ARRAY_PARAM( 2, buffer0, TraceReader::TEXT_FLOAT);
    TR.skipLine();
    CHECK_USER_CALL(glGetVertexAttribArrayObjectfvATI)
        UCT.glGetVertexAttribArrayObjectfvATI(param[0].uv32bit, param[1].uv32bit, (GLfloat *)param[2].ptr);
    CHECK_GL_CALL(glGetVertexAttribArrayObjectfvATI)
        JT.glGetVertexAttribArrayObjectfvATI(param[0].uv32bit, param[1].uv32bit, (GLfloat *)param[2].ptr);
}

void STUB_glGetVertexAttribArrayObjectivATI( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glGetVertexAttribArrayObjectivATI( GLuint, GLenum, GLint * )
    maxParam = 3;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_ARRAY_PARAM( 2, buffer0, TraceReader::TEXT_INT);
    TR.skipLine();
    CHECK_USER_CALL(glGetVertexAttribArrayObjectivATI)
        UCT.glGetVertexAttribArrayObjectivATI(param[0].uv32bit, param[1].uv32bit, (GLint *)param[2].ptr);
    CHECK_GL_CALL(glGetVertexAttribArrayObjectivATI)
        JT.glGetVertexAttribArrayObjectivATI(param[0].uv32bit, param[1].uv32bit, (GLint *)param[2].ptr);
}

void STUB_glGetVertexAttribIiv( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glGetVertexAttribIiv( GLuint, GLenum, GLint * )
    maxParam = 3;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_ARRAY_PARAM( 2, buffer0, TraceReader::TEXT_INT);
    TR.skipLine();
    CHECK_USER_CALL(glGetVertexAttribIiv)
        UCT.glGetVertexAttribIiv(param[0].uv32bit, param[1].uv32bit, (GLint *)param[2].ptr);
    CHECK_GL_CALL(glGetVertexAttribIiv)
        JT.glGetVertexAttribIiv(param[0].uv32bit, param[1].uv32bit, (GLint *)param[2].ptr);
}

void STUB_glGetVertexAttribIivEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glGetVertexAttribIivEXT( GLuint, GLenum, GLint * )
    maxParam = 3;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_ARRAY_PARAM( 2, buffer0, TraceReader::TEXT_INT);
    TR.skipLine();
    CHECK_USER_CALL(glGetVertexAttribIivEXT)
        UCT.glGetVertexAttribIivEXT(param[0].uv32bit, param[1].uv32bit, (GLint *)param[2].ptr);
    CHECK_GL_CALL(glGetVertexAttribIivEXT)
        JT.glGetVertexAttribIivEXT(param[0].uv32bit, param[1].uv32bit, (GLint *)param[2].ptr);
}

void STUB_glGetVertexAttribIuiv( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glGetVertexAttribIuiv( GLuint, GLenum, GLuint * )
    maxParam = 3;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_ARRAY_PARAM( 2, buffer0, TraceReader::TEXT_INT);
    TR.skipLine();
    CHECK_USER_CALL(glGetVertexAttribIuiv)
        UCT.glGetVertexAttribIuiv(param[0].uv32bit, param[1].uv32bit, (GLuint *)param[2].ptr);
    CHECK_GL_CALL(glGetVertexAttribIuiv)
        JT.glGetVertexAttribIuiv(param[0].uv32bit, param[1].uv32bit, (GLuint *)param[2].ptr);
}

void STUB_glGetVertexAttribIuivEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glGetVertexAttribIuivEXT( GLuint, GLenum, GLuint * )
    maxParam = 3;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_ARRAY_PARAM( 2, buffer0, TraceReader::TEXT_INT);
    TR.skipLine();
    CHECK_USER_CALL(glGetVertexAttribIuivEXT)
        UCT.glGetVertexAttribIuivEXT(param[0].uv32bit, param[1].uv32bit, (GLuint *)param[2].ptr);
    CHECK_GL_CALL(glGetVertexAttribIuivEXT)
        JT.glGetVertexAttribIuivEXT(param[0].uv32bit, param[1].uv32bit, (GLuint *)param[2].ptr);
}

void STUB_glGetVertexAttribPointerv( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glGetVertexAttribPointerv( GLuint, GLenum, GLvoid ** )
    maxParam = 3;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_ARRAY_PARAM( 2, buffer0, TraceReader::TEXT_IGNORE);
    TR.skipLine();
    CHECK_USER_CALL(glGetVertexAttribPointerv)
        UCT.glGetVertexAttribPointerv(param[0].uv32bit, param[1].uv32bit, (GLvoid **)param[2].ptr);
    CHECK_GL_CALL(glGetVertexAttribPointerv)
        JT.glGetVertexAttribPointerv(param[0].uv32bit, param[1].uv32bit, (GLvoid **)param[2].ptr);
}

void STUB_glGetVertexAttribPointervARB( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glGetVertexAttribPointervARB( GLuint, GLenum, GLvoid ** )
    maxParam = 3;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_ARRAY_PARAM( 2, buffer0, TraceReader::TEXT_IGNORE);
    TR.skipLine();
    CHECK_USER_CALL(glGetVertexAttribPointervARB)
        UCT.glGetVertexAttribPointervARB(param[0].uv32bit, param[1].uv32bit, (GLvoid **)param[2].ptr);
    CHECK_GL_CALL(glGetVertexAttribPointervARB)
        JT.glGetVertexAttribPointervARB(param[0].uv32bit, param[1].uv32bit, (GLvoid **)param[2].ptr);
}

void STUB_glGetVertexAttribPointervNV( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glGetVertexAttribPointervNV( GLuint, GLenum, GLvoid ** )
    maxParam = 3;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_ARRAY_PARAM( 2, buffer0, TraceReader::TEXT_IGNORE);
    TR.skipLine();
    CHECK_USER_CALL(glGetVertexAttribPointervNV)
        UCT.glGetVertexAttribPointervNV(param[0].uv32bit, param[1].uv32bit, (GLvoid **)param[2].ptr);
    CHECK_GL_CALL(glGetVertexAttribPointervNV)
        JT.glGetVertexAttribPointervNV(param[0].uv32bit, param[1].uv32bit, (GLvoid **)param[2].ptr);
}

void STUB_glGetVertexAttribdv( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glGetVertexAttribdv( GLuint, GLenum, GLdouble * )
    maxParam = 3;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_ARRAY_PARAM( 2, buffer0, TraceReader::TEXT_DOUBLE);
    TR.skipLine();
    CHECK_USER_CALL(glGetVertexAttribdv)
        UCT.glGetVertexAttribdv(param[0].uv32bit, param[1].uv32bit, (GLdouble *)param[2].ptr);
    CHECK_GL_CALL(glGetVertexAttribdv)
        JT.glGetVertexAttribdv(param[0].uv32bit, param[1].uv32bit, (GLdouble *)param[2].ptr);
}

void STUB_glGetVertexAttribdvARB( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glGetVertexAttribdvARB( GLuint, GLenum, GLdouble * )
    maxParam = 3;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_ARRAY_PARAM( 2, buffer0, TraceReader::TEXT_DOUBLE);
    TR.skipLine();
    CHECK_USER_CALL(glGetVertexAttribdvARB)
        UCT.glGetVertexAttribdvARB(param[0].uv32bit, param[1].uv32bit, (GLdouble *)param[2].ptr);
    CHECK_GL_CALL(glGetVertexAttribdvARB)
        JT.glGetVertexAttribdvARB(param[0].uv32bit, param[1].uv32bit, (GLdouble *)param[2].ptr);
}

void STUB_glGetVertexAttribdvNV( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glGetVertexAttribdvNV( GLuint, GLenum, GLdouble * )
    maxParam = 3;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_ARRAY_PARAM( 2, buffer0, TraceReader::TEXT_DOUBLE);
    TR.skipLine();
    CHECK_USER_CALL(glGetVertexAttribdvNV)
        UCT.glGetVertexAttribdvNV(param[0].uv32bit, param[1].uv32bit, (GLdouble *)param[2].ptr);
    CHECK_GL_CALL(glGetVertexAttribdvNV)
        JT.glGetVertexAttribdvNV(param[0].uv32bit, param[1].uv32bit, (GLdouble *)param[2].ptr);
}

void STUB_glGetVertexAttribfv( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glGetVertexAttribfv( GLuint, GLenum, GLfloat * )
    maxParam = 3;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_ARRAY_PARAM( 2, buffer0, TraceReader::TEXT_FLOAT);
    TR.skipLine();
    CHECK_USER_CALL(glGetVertexAttribfv)
        UCT.glGetVertexAttribfv(param[0].uv32bit, param[1].uv32bit, (GLfloat *)param[2].ptr);
    CHECK_GL_CALL(glGetVertexAttribfv)
        JT.glGetVertexAttribfv(param[0].uv32bit, param[1].uv32bit, (GLfloat *)param[2].ptr);
}

void STUB_glGetVertexAttribfvARB( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glGetVertexAttribfvARB( GLuint, GLenum, GLfloat * )
    maxParam = 3;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_ARRAY_PARAM( 2, buffer0, TraceReader::TEXT_FLOAT);
    TR.skipLine();
    CHECK_USER_CALL(glGetVertexAttribfvARB)
        UCT.glGetVertexAttribfvARB(param[0].uv32bit, param[1].uv32bit, (GLfloat *)param[2].ptr);
    CHECK_GL_CALL(glGetVertexAttribfvARB)
        JT.glGetVertexAttribfvARB(param[0].uv32bit, param[1].uv32bit, (GLfloat *)param[2].ptr);
}

void STUB_glGetVertexAttribfvNV( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glGetVertexAttribfvNV( GLuint, GLenum, GLfloat * )
    maxParam = 3;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_ARRAY_PARAM( 2, buffer0, TraceReader::TEXT_FLOAT);
    TR.skipLine();
    CHECK_USER_CALL(glGetVertexAttribfvNV)
        UCT.glGetVertexAttribfvNV(param[0].uv32bit, param[1].uv32bit, (GLfloat *)param[2].ptr);
    CHECK_GL_CALL(glGetVertexAttribfvNV)
        JT.glGetVertexAttribfvNV(param[0].uv32bit, param[1].uv32bit, (GLfloat *)param[2].ptr);
}

void STUB_glGetVertexAttribiv( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glGetVertexAttribiv( GLuint, GLenum, GLint * )
    maxParam = 3;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_ARRAY_PARAM( 2, buffer0, TraceReader::TEXT_INT);
    TR.skipLine();
    CHECK_USER_CALL(glGetVertexAttribiv)
        UCT.glGetVertexAttribiv(param[0].uv32bit, param[1].uv32bit, (GLint *)param[2].ptr);
    CHECK_GL_CALL(glGetVertexAttribiv)
        JT.glGetVertexAttribiv(param[0].uv32bit, param[1].uv32bit, (GLint *)param[2].ptr);
}

void STUB_glGetVertexAttribivARB( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glGetVertexAttribivARB( GLuint, GLenum, GLint * )
    maxParam = 3;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_ARRAY_PARAM( 2, buffer0, TraceReader::TEXT_INT);
    TR.skipLine();
    CHECK_USER_CALL(glGetVertexAttribivARB)
        UCT.glGetVertexAttribivARB(param[0].uv32bit, param[1].uv32bit, (GLint *)param[2].ptr);
    CHECK_GL_CALL(glGetVertexAttribivARB)
        JT.glGetVertexAttribivARB(param[0].uv32bit, param[1].uv32bit, (GLint *)param[2].ptr);
}

void STUB_glGetVertexAttribivNV( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glGetVertexAttribivNV( GLuint, GLenum, GLint * )
    maxParam = 3;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_ARRAY_PARAM( 2, buffer0, TraceReader::TEXT_INT);
    TR.skipLine();
    CHECK_USER_CALL(glGetVertexAttribivNV)
        UCT.glGetVertexAttribivNV(param[0].uv32bit, param[1].uv32bit, (GLint *)param[2].ptr);
    CHECK_GL_CALL(glGetVertexAttribivNV)
        JT.glGetVertexAttribivNV(param[0].uv32bit, param[1].uv32bit, (GLint *)param[2].ptr);
}

void STUB_glGetVideoi64vNV( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glGetVideoi64vNV( GLuint, GLenum, GLint64EXT * )
    // Call not playable
    TR.skipCall();
}

void STUB_glGetVideoivNV( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glGetVideoivNV( GLuint, GLenum, GLint * )
    maxParam = 3;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_ARRAY_PARAM( 2, buffer0, TraceReader::TEXT_INT);
    TR.skipLine();
    CHECK_USER_CALL(glGetVideoivNV)
        UCT.glGetVideoivNV(param[0].uv32bit, param[1].uv32bit, (GLint *)param[2].ptr);
    CHECK_GL_CALL(glGetVideoivNV)
        JT.glGetVideoivNV(param[0].uv32bit, param[1].uv32bit, (GLint *)param[2].ptr);
}

void STUB_glGetVideoui64vNV( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glGetVideoui64vNV( GLuint, GLenum, GLuint64EXT * )
    // Call not playable
    TR.skipCall();
}

void STUB_glGetVideouivNV( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glGetVideouivNV( GLuint, GLenum, GLuint * )
    maxParam = 3;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_ARRAY_PARAM( 2, buffer0, TraceReader::TEXT_INT);
    TR.skipLine();
    CHECK_USER_CALL(glGetVideouivNV)
        UCT.glGetVideouivNV(param[0].uv32bit, param[1].uv32bit, (GLuint *)param[2].ptr);
    CHECK_GL_CALL(glGetVideouivNV)
        JT.glGetVideouivNV(param[0].uv32bit, param[1].uv32bit, (GLuint *)param[2].ptr);
}

void STUB_glHint( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glHint( GLenum target, GLenum mode )
    maxParam = 2;
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    TR.skipLine();
    CHECK_USER_CALL(glHint)
        UCT.glHint(param[0].uv32bit, param[1].uv32bit);
    CHECK_GL_CALL(glHint)
        JT.glHint(param[0].uv32bit, param[1].uv32bit);
}

void STUB_glHintPGI( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glHintPGI( GLenum, GLint )
    maxParam = 2;
    READ_ENUM_PARAM(0);
    READ_PARAM(v32bit,1);
    TR.skipLine();
    CHECK_USER_CALL(glHintPGI)
        UCT.glHintPGI(param[0].uv32bit, param[1].v32bit);
    CHECK_GL_CALL(glHintPGI)
        JT.glHintPGI(param[0].uv32bit, param[1].v32bit);
}

void STUB_glHistogram( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glHistogram( GLenum target, GLsizei width, GLenum internalformat, GLboolean sink )
    maxParam = 4;
    READ_ENUM_PARAM(0);
    READ_PARAM(v32bit,1);
    READ_ENUM_PARAM(2);
    READ_BOOLEAN_PARAM(3);
    TR.skipLine();
    CHECK_USER_CALL(glHistogram)
        UCT.glHistogram(param[0].uv32bit, param[1].v32bit, param[2].uv32bit, param[3].boolean);
    CHECK_GL_CALL(glHistogram)
        JT.glHistogram(param[0].uv32bit, param[1].v32bit, param[2].uv32bit, param[3].boolean);
}

void STUB_glHistogramEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glHistogramEXT( GLenum, GLsizei, GLenum, GLboolean )
    maxParam = 4;
    READ_ENUM_PARAM(0);
    READ_PARAM(v32bit,1);
    READ_ENUM_PARAM(2);
    READ_BOOLEAN_PARAM(3);
    TR.skipLine();
    CHECK_USER_CALL(glHistogramEXT)
        UCT.glHistogramEXT(param[0].uv32bit, param[1].v32bit, param[2].uv32bit, param[3].boolean);
    CHECK_GL_CALL(glHistogramEXT)
        JT.glHistogramEXT(param[0].uv32bit, param[1].v32bit, param[2].uv32bit, param[3].boolean);
}

void STUB_glIglooInterfaceSGIX( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glIglooInterfaceSGIX( GLenum, const GLvoid * )
    maxParam = 2;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ARRAY_PARAM( 1, buffer0, TraceReader::TEXT_IGNORE);
    TR.skipLine();
    CHECK_USER_CALL(glIglooInterfaceSGIX)
        UCT.glIglooInterfaceSGIX(param[0].uv32bit, (const GLvoid *)param[1].ptr);
    CHECK_GL_CALL(glIglooInterfaceSGIX)
        JT.glIglooInterfaceSGIX(param[0].uv32bit, (const GLvoid *)param[1].ptr);
}

void STUB_glImageTransformParameterfHP( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glImageTransformParameterfHP( GLenum, GLenum, GLfloat )
    maxParam = 3;
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_PARAM(fv32bit,2);
    TR.skipLine();
    CHECK_USER_CALL(glImageTransformParameterfHP)
        UCT.glImageTransformParameterfHP(param[0].uv32bit, param[1].uv32bit, param[2].fv32bit);
    CHECK_GL_CALL(glImageTransformParameterfHP)
        JT.glImageTransformParameterfHP(param[0].uv32bit, param[1].uv32bit, param[2].fv32bit);
}

void STUB_glImageTransformParameterfvHP( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glImageTransformParameterfvHP( GLenum, GLenum, const GLfloat * )
    maxParam = 3;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_ARRAY_PARAM( 2, buffer0, TraceReader::TEXT_FLOAT);
    TR.skipLine();
    CHECK_USER_CALL(glImageTransformParameterfvHP)
        UCT.glImageTransformParameterfvHP(param[0].uv32bit, param[1].uv32bit, (const GLfloat *)param[2].ptr);
    CHECK_GL_CALL(glImageTransformParameterfvHP)
        JT.glImageTransformParameterfvHP(param[0].uv32bit, param[1].uv32bit, (const GLfloat *)param[2].ptr);
}

void STUB_glImageTransformParameteriHP( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glImageTransformParameteriHP( GLenum, GLenum, GLint )
    maxParam = 3;
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_PARAM(v32bit,2);
    TR.skipLine();
    CHECK_USER_CALL(glImageTransformParameteriHP)
        UCT.glImageTransformParameteriHP(param[0].uv32bit, param[1].uv32bit, param[2].v32bit);
    CHECK_GL_CALL(glImageTransformParameteriHP)
        JT.glImageTransformParameteriHP(param[0].uv32bit, param[1].uv32bit, param[2].v32bit);
}

void STUB_glImageTransformParameterivHP( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glImageTransformParameterivHP( GLenum, GLenum, const GLint * )
    maxParam = 3;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_ARRAY_PARAM( 2, buffer0, TraceReader::TEXT_INT);
    TR.skipLine();
    CHECK_USER_CALL(glImageTransformParameterivHP)
        UCT.glImageTransformParameterivHP(param[0].uv32bit, param[1].uv32bit, (const GLint *)param[2].ptr);
    CHECK_GL_CALL(glImageTransformParameterivHP)
        JT.glImageTransformParameterivHP(param[0].uv32bit, param[1].uv32bit, (const GLint *)param[2].ptr);
}

void STUB_glIndexFuncEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glIndexFuncEXT( GLenum, GLclampf )
    maxParam = 2;
    READ_ENUM_PARAM(0);
    READ_PARAM(fv32bit,1);
    TR.skipLine();
    CHECK_USER_CALL(glIndexFuncEXT)
        UCT.glIndexFuncEXT(param[0].uv32bit, param[1].fv32bit);
    CHECK_GL_CALL(glIndexFuncEXT)
        JT.glIndexFuncEXT(param[0].uv32bit, param[1].fv32bit);
}

void STUB_glIndexMask( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glIndexMask( GLuint mask )
    maxParam = 1;
    READ_ENUM_PARAM(0);
    TR.skipLine();
    CHECK_USER_CALL(glIndexMask)
        UCT.glIndexMask(param[0].uv32bit);
    CHECK_GL_CALL(glIndexMask)
        JT.glIndexMask(param[0].uv32bit);
}

void STUB_glIndexMaterialEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glIndexMaterialEXT( GLenum, GLenum )
    maxParam = 2;
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    TR.skipLine();
    CHECK_USER_CALL(glIndexMaterialEXT)
        UCT.glIndexMaterialEXT(param[0].uv32bit, param[1].uv32bit);
    CHECK_GL_CALL(glIndexMaterialEXT)
        JT.glIndexMaterialEXT(param[0].uv32bit, param[1].uv32bit);
}

void STUB_glIndexPointer( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glIndexPointer( GLenum type, GLsizei stride, const GLvoid *ptr )
    maxParam = 3;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_PARAM(v32bit,1);
    READ_ARRAY_PARAM( 2, buffer0, TraceReader::TEXT_IGNORE);
    TR.skipLine();
    CHECK_USER_CALL(glIndexPointer)
        UCT.glIndexPointer(param[0].uv32bit, param[1].v32bit, (const GLvoid *)param[2].ptr);
    CHECK_GL_CALL(glIndexPointer)
        JT.glIndexPointer(param[0].uv32bit, param[1].v32bit, (const GLvoid *)param[2].ptr);
}

void STUB_glIndexPointerEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glIndexPointerEXT( GLenum, GLsizei, GLsizei, const GLvoid * )
    maxParam = 4;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_PARAM(v32bit,1);
    READ_PARAM(v32bit,2);
    READ_ARRAY_PARAM( 3, buffer0, TraceReader::TEXT_IGNORE);
    TR.skipLine();
    CHECK_USER_CALL(glIndexPointerEXT)
        UCT.glIndexPointerEXT(param[0].uv32bit, param[1].v32bit, param[2].v32bit, (const GLvoid *)param[3].ptr);
    CHECK_GL_CALL(glIndexPointerEXT)
        JT.glIndexPointerEXT(param[0].uv32bit, param[1].v32bit, param[2].v32bit, (const GLvoid *)param[3].ptr);
}

void STUB_glIndexd( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glIndexd( GLdouble c )
    maxParam = 1;
    READ_DOUBLE_PARAM(0);
    TR.skipLine();
    CHECK_USER_CALL(glIndexd)
        UCT.glIndexd(param[0].fv64bit);
    CHECK_GL_CALL(glIndexd)
        JT.glIndexd(param[0].fv64bit);
}

void STUB_glIndexdv( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glIndexdv( const GLdouble *c )
    maxParam = 1;
    char buffer0[16*4096];
    READ_ARRAY_PARAM( 0, buffer0, TraceReader::TEXT_DOUBLE);
    TR.skipLine();
    CHECK_USER_CALL(glIndexdv)
        UCT.glIndexdv((const GLdouble *)param[0].ptr);
    CHECK_GL_CALL(glIndexdv)
        JT.glIndexdv((const GLdouble *)param[0].ptr);
}

void STUB_glIndexf( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glIndexf( GLfloat c )
    maxParam = 1;
    READ_PARAM(fv32bit,0);
    TR.skipLine();
    CHECK_USER_CALL(glIndexf)
        UCT.glIndexf(param[0].fv32bit);
    CHECK_GL_CALL(glIndexf)
        JT.glIndexf(param[0].fv32bit);
}

void STUB_glIndexfv( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glIndexfv( const GLfloat *c )
    maxParam = 1;
    char buffer0[16*4096];
    READ_ARRAY_PARAM( 0, buffer0, TraceReader::TEXT_FLOAT);
    TR.skipLine();
    CHECK_USER_CALL(glIndexfv)
        UCT.glIndexfv((const GLfloat *)param[0].ptr);
    CHECK_GL_CALL(glIndexfv)
        JT.glIndexfv((const GLfloat *)param[0].ptr);
}

void STUB_glIndexi( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glIndexi( GLint c )
    maxParam = 1;
    READ_PARAM(v32bit,0);
    TR.skipLine();
    CHECK_USER_CALL(glIndexi)
        UCT.glIndexi(param[0].v32bit);
    CHECK_GL_CALL(glIndexi)
        JT.glIndexi(param[0].v32bit);
}

void STUB_glIndexiv( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glIndexiv( const GLint *c )
    maxParam = 1;
    char buffer0[16*4096];
    READ_ARRAY_PARAM( 0, buffer0, TraceReader::TEXT_INT);
    TR.skipLine();
    CHECK_USER_CALL(glIndexiv)
        UCT.glIndexiv((const GLint *)param[0].ptr);
    CHECK_GL_CALL(glIndexiv)
        JT.glIndexiv((const GLint *)param[0].ptr);
}

void STUB_glIndexs( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glIndexs( GLshort c )
    maxParam = 1;
    READ_PARAM(v16bit,0);
    TR.skipLine();
    CHECK_USER_CALL(glIndexs)
        UCT.glIndexs(param[0].v16bit);
    CHECK_GL_CALL(glIndexs)
        JT.glIndexs(param[0].v16bit);
}

void STUB_glIndexsv( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glIndexsv( const GLshort *c )
    maxParam = 1;
    char buffer0[16*4096];
    READ_ARRAY_PARAM( 0, buffer0, TraceReader::TEXT_SHORT);
    TR.skipLine();
    CHECK_USER_CALL(glIndexsv)
        UCT.glIndexsv((const GLshort *)param[0].ptr);
    CHECK_GL_CALL(glIndexsv)
        JT.glIndexsv((const GLshort *)param[0].ptr);
}

void STUB_glIndexub( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glIndexub( GLubyte c )
    maxParam = 1;
    READ_PARAM(uv8bit,0);
    TR.skipLine();
    CHECK_USER_CALL(glIndexub)
        UCT.glIndexub(param[0].uv8bit);
    CHECK_GL_CALL(glIndexub)
        JT.glIndexub(param[0].uv8bit);
}

void STUB_glIndexubv( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glIndexubv( const GLubyte *c )
    maxParam = 1;
    char buffer0[16*4096];
    READ_ARRAY_PARAM( 0, buffer0, TraceReader::TEXT_BYTE);
    TR.skipLine();
    CHECK_USER_CALL(glIndexubv)
        UCT.glIndexubv((const GLubyte *)param[0].ptr);
    CHECK_GL_CALL(glIndexubv)
        JT.glIndexubv((const GLubyte *)param[0].ptr);
}

void STUB_glInitNames( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glInitNames(  )
    maxParam = 0;
    TR.skipLine();
    CHECK_USER_CALL(glInitNames)
        UCT.glInitNames();
    CHECK_GL_CALL(glInitNames)
        JT.glInitNames();
}

void STUB_glInsertComponentEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glInsertComponentEXT( GLuint, GLuint, GLuint )
    maxParam = 3;
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_ENUM_PARAM(2);
    TR.skipLine();
    CHECK_USER_CALL(glInsertComponentEXT)
        UCT.glInsertComponentEXT(param[0].uv32bit, param[1].uv32bit, param[2].uv32bit);
    CHECK_GL_CALL(glInsertComponentEXT)
        JT.glInsertComponentEXT(param[0].uv32bit, param[1].uv32bit, param[2].uv32bit);
}

void STUB_glInstrumentsBufferSGIX( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glInstrumentsBufferSGIX( GLsizei, GLint * )
    maxParam = 2;
    char buffer0[16*4096];
    READ_PARAM(v32bit,0);
    READ_ARRAY_PARAM( 1, buffer0, TraceReader::TEXT_INT);
    TR.skipLine();
    CHECK_USER_CALL(glInstrumentsBufferSGIX)
        UCT.glInstrumentsBufferSGIX(param[0].v32bit, (GLint *)param[1].ptr);
    CHECK_GL_CALL(glInstrumentsBufferSGIX)
        JT.glInstrumentsBufferSGIX(param[0].v32bit, (GLint *)param[1].ptr);
}

void STUB_glInterleavedArrays( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glInterleavedArrays( GLenum format, GLsizei stride, const GLvoid *pointer )
    maxParam = 3;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_PARAM(v32bit,1);
    READ_ARRAY_PARAM( 2, buffer0, TraceReader::TEXT_IGNORE);
    TR.skipLine();
    CHECK_USER_CALL(glInterleavedArrays)
        UCT.glInterleavedArrays(param[0].uv32bit, param[1].v32bit, (const GLvoid *)param[2].ptr);
    CHECK_GL_CALL(glInterleavedArrays)
        JT.glInterleavedArrays(param[0].uv32bit, param[1].v32bit, (const GLvoid *)param[2].ptr);
}

void STUB_glIsAsyncMarkerSGIX( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // GLboolean glIsAsyncMarkerSGIX( GLuint )
    maxParam = 1;
    READ_ENUM_PARAM(0);
    TR.skipResult();
    TR.skipLine();
    CHECK_USER_CALL(glIsAsyncMarkerSGIX)
        UCT.glIsAsyncMarkerSGIX(param[0].uv32bit);
    CHECK_GL_CALL(glIsAsyncMarkerSGIX)
        JT.glIsAsyncMarkerSGIX(param[0].uv32bit);
}

void STUB_glIsBuffer( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // GLboolean glIsBuffer( GLuint )
    maxParam = 1;
    READ_ENUM_PARAM(0);
    TR.skipResult();
    TR.skipLine();
    CHECK_USER_CALL(glIsBuffer)
        UCT.glIsBuffer(param[0].uv32bit);
    CHECK_GL_CALL(glIsBuffer)
        JT.glIsBuffer(param[0].uv32bit);
}

void STUB_glIsBufferARB( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // GLboolean glIsBufferARB( GLuint )
    maxParam = 1;
    READ_ENUM_PARAM(0);
    TR.skipResult();
    TR.skipLine();
    CHECK_USER_CALL(glIsBufferARB)
        UCT.glIsBufferARB(param[0].uv32bit);
    CHECK_GL_CALL(glIsBufferARB)
        JT.glIsBufferARB(param[0].uv32bit);
}

void STUB_glIsEnabled( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // GLboolean glIsEnabled( GLenum cap )
    maxParam = 1;
    READ_ENUM_PARAM(0);
    TR.skipResult();
    TR.skipLine();
    CHECK_USER_CALL(glIsEnabled)
        UCT.glIsEnabled(param[0].uv32bit);
    CHECK_GL_CALL(glIsEnabled)
        JT.glIsEnabled(param[0].uv32bit);
}

void STUB_glIsEnabledIndexedEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // GLboolean glIsEnabledIndexedEXT( GLenum, GLuint )
    maxParam = 2;
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    TR.skipResult();
    TR.skipLine();
    CHECK_USER_CALL(glIsEnabledIndexedEXT)
        UCT.glIsEnabledIndexedEXT(param[0].uv32bit, param[1].uv32bit);
    CHECK_GL_CALL(glIsEnabledIndexedEXT)
        JT.glIsEnabledIndexedEXT(param[0].uv32bit, param[1].uv32bit);
}

void STUB_glIsEnabledi( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // GLboolean glIsEnabledi( GLenum, GLuint )
    maxParam = 2;
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    TR.skipResult();
    TR.skipLine();
    CHECK_USER_CALL(glIsEnabledi)
        UCT.glIsEnabledi(param[0].uv32bit, param[1].uv32bit);
    CHECK_GL_CALL(glIsEnabledi)
        JT.glIsEnabledi(param[0].uv32bit, param[1].uv32bit);
}

void STUB_glIsFenceAPPLE( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // GLboolean glIsFenceAPPLE( GLuint )
    maxParam = 1;
    READ_ENUM_PARAM(0);
    TR.skipResult();
    TR.skipLine();
    CHECK_USER_CALL(glIsFenceAPPLE)
        UCT.glIsFenceAPPLE(param[0].uv32bit);
    CHECK_GL_CALL(glIsFenceAPPLE)
        JT.glIsFenceAPPLE(param[0].uv32bit);
}

void STUB_glIsFenceNV( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // GLboolean glIsFenceNV( GLuint )
    maxParam = 1;
    READ_ENUM_PARAM(0);
    TR.skipResult();
    TR.skipLine();
    CHECK_USER_CALL(glIsFenceNV)
        UCT.glIsFenceNV(param[0].uv32bit);
    CHECK_GL_CALL(glIsFenceNV)
        JT.glIsFenceNV(param[0].uv32bit);
}

void STUB_glIsFramebuffer( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // GLboolean glIsFramebuffer( GLuint )
    maxParam = 1;
    READ_ENUM_PARAM(0);
    TR.skipResult();
    TR.skipLine();
    CHECK_USER_CALL(glIsFramebuffer)
        UCT.glIsFramebuffer(param[0].uv32bit);
    CHECK_GL_CALL(glIsFramebuffer)
        JT.glIsFramebuffer(param[0].uv32bit);
}

void STUB_glIsFramebufferEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // GLboolean glIsFramebufferEXT( GLuint )
    maxParam = 1;
    READ_ENUM_PARAM(0);
    TR.skipResult();
    TR.skipLine();
    CHECK_USER_CALL(glIsFramebufferEXT)
        UCT.glIsFramebufferEXT(param[0].uv32bit);
    CHECK_GL_CALL(glIsFramebufferEXT)
        JT.glIsFramebufferEXT(param[0].uv32bit);
}

void STUB_glIsList( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // GLboolean glIsList( GLuint list )
    maxParam = 1;
    READ_ENUM_PARAM(0);
    TR.skipResult();
    TR.skipLine();
    CHECK_USER_CALL(glIsList)
        UCT.glIsList(param[0].uv32bit);
    CHECK_GL_CALL(glIsList)
        JT.glIsList(param[0].uv32bit);
}

void STUB_glIsObjectBufferATI( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // GLboolean glIsObjectBufferATI( GLuint )
    maxParam = 1;
    READ_ENUM_PARAM(0);
    TR.skipResult();
    TR.skipLine();
    CHECK_USER_CALL(glIsObjectBufferATI)
        UCT.glIsObjectBufferATI(param[0].uv32bit);
    CHECK_GL_CALL(glIsObjectBufferATI)
        JT.glIsObjectBufferATI(param[0].uv32bit);
}

void STUB_glIsOcclusionQueryNV( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // GLboolean glIsOcclusionQueryNV( GLuint )
    maxParam = 1;
    READ_ENUM_PARAM(0);
    TR.skipResult();
    TR.skipLine();
    CHECK_USER_CALL(glIsOcclusionQueryNV)
        UCT.glIsOcclusionQueryNV(param[0].uv32bit);
    CHECK_GL_CALL(glIsOcclusionQueryNV)
        JT.glIsOcclusionQueryNV(param[0].uv32bit);
}

void STUB_glIsProgram( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // GLboolean glIsProgram( GLuint )
    maxParam = 1;
    READ_ENUM_PARAM(0);
    TR.skipResult();
    TR.skipLine();
    CHECK_USER_CALL(glIsProgram)
        UCT.glIsProgram(param[0].uv32bit);
    CHECK_GL_CALL(glIsProgram)
        JT.glIsProgram(param[0].uv32bit);
}

void STUB_glIsProgramARB( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // GLboolean glIsProgramARB( GLuint )
    maxParam = 1;
    READ_ENUM_PARAM(0);
    TR.skipResult();
    TR.skipLine();
    CHECK_USER_CALL(glIsProgramARB)
        UCT.glIsProgramARB(param[0].uv32bit);
    CHECK_GL_CALL(glIsProgramARB)
        JT.glIsProgramARB(param[0].uv32bit);
}

void STUB_glIsProgramNV( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // GLboolean glIsProgramNV( GLuint )
    maxParam = 1;
    READ_ENUM_PARAM(0);
    TR.skipResult();
    TR.skipLine();
    CHECK_USER_CALL(glIsProgramNV)
        UCT.glIsProgramNV(param[0].uv32bit);
    CHECK_GL_CALL(glIsProgramNV)
        JT.glIsProgramNV(param[0].uv32bit);
}

void STUB_glIsQuery( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // GLboolean glIsQuery( GLuint )
    maxParam = 1;
    READ_ENUM_PARAM(0);
    TR.skipResult();
    TR.skipLine();
    CHECK_USER_CALL(glIsQuery)
        UCT.glIsQuery(param[0].uv32bit);
    CHECK_GL_CALL(glIsQuery)
        JT.glIsQuery(param[0].uv32bit);
}

void STUB_glIsQueryARB( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // GLboolean glIsQueryARB( GLuint )
    maxParam = 1;
    READ_ENUM_PARAM(0);
    TR.skipResult();
    TR.skipLine();
    CHECK_USER_CALL(glIsQueryARB)
        UCT.glIsQueryARB(param[0].uv32bit);
    CHECK_GL_CALL(glIsQueryARB)
        JT.glIsQueryARB(param[0].uv32bit);
}

void STUB_glIsRenderbuffer( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // GLboolean glIsRenderbuffer( GLuint )
    maxParam = 1;
    READ_ENUM_PARAM(0);
    TR.skipResult();
    TR.skipLine();
    CHECK_USER_CALL(glIsRenderbuffer)
        UCT.glIsRenderbuffer(param[0].uv32bit);
    CHECK_GL_CALL(glIsRenderbuffer)
        JT.glIsRenderbuffer(param[0].uv32bit);
}

void STUB_glIsRenderbufferEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // GLboolean glIsRenderbufferEXT( GLuint )
    maxParam = 1;
    READ_ENUM_PARAM(0);
    TR.skipResult();
    TR.skipLine();
    CHECK_USER_CALL(glIsRenderbufferEXT)
        UCT.glIsRenderbufferEXT(param[0].uv32bit);
    CHECK_GL_CALL(glIsRenderbufferEXT)
        JT.glIsRenderbufferEXT(param[0].uv32bit);
}

void STUB_glIsShader( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // GLboolean glIsShader( GLuint )
    maxParam = 1;
    READ_ENUM_PARAM(0);
    TR.skipResult();
    TR.skipLine();
    CHECK_USER_CALL(glIsShader)
        UCT.glIsShader(param[0].uv32bit);
    CHECK_GL_CALL(glIsShader)
        JT.glIsShader(param[0].uv32bit);
}

void STUB_glIsTexture( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // GLboolean glIsTexture( GLuint texture )
    maxParam = 1;
    READ_ENUM_PARAM(0);
    TR.skipResult();
    TR.skipLine();
    CHECK_USER_CALL(glIsTexture)
        UCT.glIsTexture(param[0].uv32bit);
    CHECK_GL_CALL(glIsTexture)
        JT.glIsTexture(param[0].uv32bit);
}

void STUB_glIsTextureEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // GLboolean glIsTextureEXT( GLuint )
    maxParam = 1;
    READ_ENUM_PARAM(0);
    TR.skipResult();
    TR.skipLine();
    CHECK_USER_CALL(glIsTextureEXT)
        UCT.glIsTextureEXT(param[0].uv32bit);
    CHECK_GL_CALL(glIsTextureEXT)
        JT.glIsTextureEXT(param[0].uv32bit);
}

void STUB_glIsTransformFeedbackNV( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // GLboolean glIsTransformFeedbackNV( GLuint )
    maxParam = 1;
    READ_ENUM_PARAM(0);
    TR.skipResult();
    TR.skipLine();
    CHECK_USER_CALL(glIsTransformFeedbackNV)
        UCT.glIsTransformFeedbackNV(param[0].uv32bit);
    CHECK_GL_CALL(glIsTransformFeedbackNV)
        JT.glIsTransformFeedbackNV(param[0].uv32bit);
}

void STUB_glIsVariantEnabledEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // GLboolean glIsVariantEnabledEXT( GLuint, GLenum )
    maxParam = 2;
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    TR.skipResult();
    TR.skipLine();
    CHECK_USER_CALL(glIsVariantEnabledEXT)
        UCT.glIsVariantEnabledEXT(param[0].uv32bit, param[1].uv32bit);
    CHECK_GL_CALL(glIsVariantEnabledEXT)
        JT.glIsVariantEnabledEXT(param[0].uv32bit, param[1].uv32bit);
}

void STUB_glIsVertexArray( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // GLboolean glIsVertexArray( GLuint )
    maxParam = 1;
    READ_ENUM_PARAM(0);
    TR.skipResult();
    TR.skipLine();
    CHECK_USER_CALL(glIsVertexArray)
        UCT.glIsVertexArray(param[0].uv32bit);
    CHECK_GL_CALL(glIsVertexArray)
        JT.glIsVertexArray(param[0].uv32bit);
}

void STUB_glIsVertexArrayAPPLE( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // GLboolean glIsVertexArrayAPPLE( GLuint )
    maxParam = 1;
    READ_ENUM_PARAM(0);
    TR.skipResult();
    TR.skipLine();
    CHECK_USER_CALL(glIsVertexArrayAPPLE)
        UCT.glIsVertexArrayAPPLE(param[0].uv32bit);
    CHECK_GL_CALL(glIsVertexArrayAPPLE)
        JT.glIsVertexArrayAPPLE(param[0].uv32bit);
}

void STUB_glLightEnviSGIX( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glLightEnviSGIX( GLenum, GLint )
    maxParam = 2;
    READ_ENUM_PARAM(0);
    READ_PARAM(v32bit,1);
    TR.skipLine();
    CHECK_USER_CALL(glLightEnviSGIX)
        UCT.glLightEnviSGIX(param[0].uv32bit, param[1].v32bit);
    CHECK_GL_CALL(glLightEnviSGIX)
        JT.glLightEnviSGIX(param[0].uv32bit, param[1].v32bit);
}

void STUB_glLightModelf( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glLightModelf( GLenum pname, GLfloat param )
    maxParam = 2;
    READ_ENUM_PARAM(0);
    READ_PARAM(fv32bit,1);
    TR.skipLine();
    CHECK_USER_CALL(glLightModelf)
        UCT.glLightModelf(param[0].uv32bit, param[1].fv32bit);
    CHECK_GL_CALL(glLightModelf)
        JT.glLightModelf(param[0].uv32bit, param[1].fv32bit);
}

void STUB_glLightModelfv( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glLightModelfv( GLenum pname, const GLfloat *params )
    maxParam = 2;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ARRAY_PARAM( 1, buffer0, TraceReader::TEXT_FLOAT);
    TR.skipLine();
    CHECK_USER_CALL(glLightModelfv)
        UCT.glLightModelfv(param[0].uv32bit, (const GLfloat *)param[1].ptr);
    CHECK_GL_CALL(glLightModelfv)
        JT.glLightModelfv(param[0].uv32bit, (const GLfloat *)param[1].ptr);
}

void STUB_glLightModeli( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glLightModeli( GLenum pname, GLint param )
    maxParam = 2;
    READ_ENUM_PARAM(0);
    READ_PARAM(v32bit,1);
    TR.skipLine();
    CHECK_USER_CALL(glLightModeli)
        UCT.glLightModeli(param[0].uv32bit, param[1].v32bit);
    CHECK_GL_CALL(glLightModeli)
        JT.glLightModeli(param[0].uv32bit, param[1].v32bit);
}

void STUB_glLightModeliv( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glLightModeliv( GLenum pname, const GLint *params )
    maxParam = 2;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ARRAY_PARAM( 1, buffer0, TraceReader::TEXT_INT);
    TR.skipLine();
    CHECK_USER_CALL(glLightModeliv)
        UCT.glLightModeliv(param[0].uv32bit, (const GLint *)param[1].ptr);
    CHECK_GL_CALL(glLightModeliv)
        JT.glLightModeliv(param[0].uv32bit, (const GLint *)param[1].ptr);
}

void STUB_glLightf( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glLightf( GLenum light, GLenum pname, GLfloat param )
    maxParam = 3;
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_PARAM(fv32bit,2);
    TR.skipLine();
    CHECK_USER_CALL(glLightf)
        UCT.glLightf(param[0].uv32bit, param[1].uv32bit, param[2].fv32bit);
    CHECK_GL_CALL(glLightf)
        JT.glLightf(param[0].uv32bit, param[1].uv32bit, param[2].fv32bit);
}

void STUB_glLightfv( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glLightfv( GLenum light, GLenum pname, const GLfloat *params )
    maxParam = 3;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_ARRAY_PARAM( 2, buffer0, TraceReader::TEXT_FLOAT);
    TR.skipLine();
    CHECK_USER_CALL(glLightfv)
        UCT.glLightfv(param[0].uv32bit, param[1].uv32bit, (const GLfloat *)param[2].ptr);
    CHECK_GL_CALL(glLightfv)
        JT.glLightfv(param[0].uv32bit, param[1].uv32bit, (const GLfloat *)param[2].ptr);
}

void STUB_glLighti( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glLighti( GLenum light, GLenum pname, GLint param )
    maxParam = 3;
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_PARAM(v32bit,2);
    TR.skipLine();
    CHECK_USER_CALL(glLighti)
        UCT.glLighti(param[0].uv32bit, param[1].uv32bit, param[2].v32bit);
    CHECK_GL_CALL(glLighti)
        JT.glLighti(param[0].uv32bit, param[1].uv32bit, param[2].v32bit);
}

void STUB_glLightiv( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glLightiv( GLenum light, GLenum pname, const GLint *params )
    maxParam = 3;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_ARRAY_PARAM( 2, buffer0, TraceReader::TEXT_INT);
    TR.skipLine();
    CHECK_USER_CALL(glLightiv)
        UCT.glLightiv(param[0].uv32bit, param[1].uv32bit, (const GLint *)param[2].ptr);
    CHECK_GL_CALL(glLightiv)
        JT.glLightiv(param[0].uv32bit, param[1].uv32bit, (const GLint *)param[2].ptr);
}

void STUB_glLineStipple( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glLineStipple( GLint factor, GLushort pattern )
    maxParam = 2;
    READ_PARAM(v32bit,0);
    READ_PARAM(uv16bit,1);
    TR.skipLine();
    CHECK_USER_CALL(glLineStipple)
        UCT.glLineStipple(param[0].v32bit, param[1].uv16bit);
    CHECK_GL_CALL(glLineStipple)
        JT.glLineStipple(param[0].v32bit, param[1].uv16bit);
}

void STUB_glLineWidth( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glLineWidth( GLfloat width )
    maxParam = 1;
    READ_PARAM(fv32bit,0);
    TR.skipLine();
    CHECK_USER_CALL(glLineWidth)
        UCT.glLineWidth(param[0].fv32bit);
    CHECK_GL_CALL(glLineWidth)
        JT.glLineWidth(param[0].fv32bit);
}

void STUB_glLinkProgram( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glLinkProgram( GLuint )
    maxParam = 1;
    READ_ENUM_PARAM(0);
    TR.skipLine();
    CHECK_USER_CALL(glLinkProgram)
        UCT.glLinkProgram(param[0].uv32bit);
    CHECK_GL_CALL(glLinkProgram)
        JT.glLinkProgram(param[0].uv32bit);
}

void STUB_glLinkProgramARB( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glLinkProgramARB( GLhandleARB )
    maxParam = 1;
    READ_ENUM_PARAM(0);
    TR.skipLine();
    CHECK_USER_CALL(glLinkProgramARB)
        UCT.glLinkProgramARB(param[0].uv32bit);
    CHECK_GL_CALL(glLinkProgramARB)
        JT.glLinkProgramARB(param[0].uv32bit);
}

void STUB_glListBase( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glListBase( GLuint base )
    maxParam = 1;
    READ_ENUM_PARAM(0);
    TR.skipLine();
    CHECK_USER_CALL(glListBase)
        UCT.glListBase(param[0].uv32bit);
    CHECK_GL_CALL(glListBase)
        JT.glListBase(param[0].uv32bit);
}

void STUB_glListParameterfSGIX( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glListParameterfSGIX( GLuint, GLenum, GLfloat )
    maxParam = 3;
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_PARAM(fv32bit,2);
    TR.skipLine();
    CHECK_USER_CALL(glListParameterfSGIX)
        UCT.glListParameterfSGIX(param[0].uv32bit, param[1].uv32bit, param[2].fv32bit);
    CHECK_GL_CALL(glListParameterfSGIX)
        JT.glListParameterfSGIX(param[0].uv32bit, param[1].uv32bit, param[2].fv32bit);
}

void STUB_glListParameterfvSGIX( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glListParameterfvSGIX( GLuint, GLenum, const GLfloat * )
    maxParam = 3;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_ARRAY_PARAM( 2, buffer0, TraceReader::TEXT_FLOAT);
    TR.skipLine();
    CHECK_USER_CALL(glListParameterfvSGIX)
        UCT.glListParameterfvSGIX(param[0].uv32bit, param[1].uv32bit, (const GLfloat *)param[2].ptr);
    CHECK_GL_CALL(glListParameterfvSGIX)
        JT.glListParameterfvSGIX(param[0].uv32bit, param[1].uv32bit, (const GLfloat *)param[2].ptr);
}

void STUB_glListParameteriSGIX( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glListParameteriSGIX( GLuint, GLenum, GLint )
    maxParam = 3;
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_PARAM(v32bit,2);
    TR.skipLine();
    CHECK_USER_CALL(glListParameteriSGIX)
        UCT.glListParameteriSGIX(param[0].uv32bit, param[1].uv32bit, param[2].v32bit);
    CHECK_GL_CALL(glListParameteriSGIX)
        JT.glListParameteriSGIX(param[0].uv32bit, param[1].uv32bit, param[2].v32bit);
}

void STUB_glListParameterivSGIX( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glListParameterivSGIX( GLuint, GLenum, const GLint * )
    maxParam = 3;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_ARRAY_PARAM( 2, buffer0, TraceReader::TEXT_INT);
    TR.skipLine();
    CHECK_USER_CALL(glListParameterivSGIX)
        UCT.glListParameterivSGIX(param[0].uv32bit, param[1].uv32bit, (const GLint *)param[2].ptr);
    CHECK_GL_CALL(glListParameterivSGIX)
        JT.glListParameterivSGIX(param[0].uv32bit, param[1].uv32bit, (const GLint *)param[2].ptr);
}

void STUB_glLoadIdentity( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glLoadIdentity(  )
    maxParam = 0;
    TR.skipLine();
    CHECK_USER_CALL(glLoadIdentity)
        UCT.glLoadIdentity();
    CHECK_GL_CALL(glLoadIdentity)
        JT.glLoadIdentity();
}

void STUB_glLoadIdentityDeformationMapSGIX( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glLoadIdentityDeformationMapSGIX( GLbitfield )
    maxParam = 1;
    READ_ORING_PARAM(0);
    TR.skipLine();
    CHECK_USER_CALL(glLoadIdentityDeformationMapSGIX)
        UCT.glLoadIdentityDeformationMapSGIX(param[0].uv32bit);
    CHECK_GL_CALL(glLoadIdentityDeformationMapSGIX)
        JT.glLoadIdentityDeformationMapSGIX(param[0].uv32bit);
}

void STUB_glLoadMatrixd( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glLoadMatrixd( const GLdouble *m )
    maxParam = 1;
    char buffer0[16*4096];
    READ_ARRAY_PARAM( 0, buffer0, TraceReader::TEXT_DOUBLE);
    TR.skipLine();
    CHECK_USER_CALL(glLoadMatrixd)
        UCT.glLoadMatrixd((const GLdouble *)param[0].ptr);
    CHECK_GL_CALL(glLoadMatrixd)
        JT.glLoadMatrixd((const GLdouble *)param[0].ptr);
}

void STUB_glLoadMatrixf( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glLoadMatrixf( const GLfloat *m )
    maxParam = 1;
    char buffer0[16*4096];
    READ_ARRAY_PARAM( 0, buffer0, TraceReader::TEXT_FLOAT);
    TR.skipLine();
    CHECK_USER_CALL(glLoadMatrixf)
        UCT.glLoadMatrixf((const GLfloat *)param[0].ptr);
    CHECK_GL_CALL(glLoadMatrixf)
        JT.glLoadMatrixf((const GLfloat *)param[0].ptr);
}

void STUB_glLoadName( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glLoadName( GLuint name )
    maxParam = 1;
    READ_ENUM_PARAM(0);
    TR.skipLine();
    CHECK_USER_CALL(glLoadName)
        UCT.glLoadName(param[0].uv32bit);
    CHECK_GL_CALL(glLoadName)
        JT.glLoadName(param[0].uv32bit);
}

void STUB_glLoadProgramNV( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glLoadProgramNV( GLenum, GLuint, GLsizei, const GLubyte * )
    maxParam = 4;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_PARAM(v32bit,2);
    READ_ARRAY_PARAM( 3, buffer0, TraceReader::TEXT_BYTE);
    TR.skipLine();
    CHECK_USER_CALL(glLoadProgramNV)
        UCT.glLoadProgramNV(param[0].uv32bit, param[1].uv32bit, param[2].v32bit, (const GLubyte *)param[3].ptr);
    CHECK_GL_CALL(glLoadProgramNV)
        JT.glLoadProgramNV(param[0].uv32bit, param[1].uv32bit, param[2].v32bit, (const GLubyte *)param[3].ptr);
}

void STUB_glLoadTransposeMatrixd( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glLoadTransposeMatrixd( const GLdouble *m )
    maxParam = 1;
    char buffer0[16*4096];
    READ_ARRAY_PARAM( 0, buffer0, TraceReader::TEXT_DOUBLE);
    TR.skipLine();
    CHECK_USER_CALL(glLoadTransposeMatrixd)
        UCT.glLoadTransposeMatrixd((const GLdouble *)param[0].ptr);
    CHECK_GL_CALL(glLoadTransposeMatrixd)
        JT.glLoadTransposeMatrixd((const GLdouble *)param[0].ptr);
}

void STUB_glLoadTransposeMatrixdARB( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glLoadTransposeMatrixdARB( const GLdouble * )
    maxParam = 1;
    char buffer0[16*4096];
    READ_ARRAY_PARAM( 0, buffer0, TraceReader::TEXT_DOUBLE);
    TR.skipLine();
    CHECK_USER_CALL(glLoadTransposeMatrixdARB)
        UCT.glLoadTransposeMatrixdARB((const GLdouble *)param[0].ptr);
    CHECK_GL_CALL(glLoadTransposeMatrixdARB)
        JT.glLoadTransposeMatrixdARB((const GLdouble *)param[0].ptr);
}

void STUB_glLoadTransposeMatrixf( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glLoadTransposeMatrixf( const GLfloat *m )
    maxParam = 1;
    char buffer0[16*4096];
    READ_ARRAY_PARAM( 0, buffer0, TraceReader::TEXT_FLOAT);
    TR.skipLine();
    CHECK_USER_CALL(glLoadTransposeMatrixf)
        UCT.glLoadTransposeMatrixf((const GLfloat *)param[0].ptr);
    CHECK_GL_CALL(glLoadTransposeMatrixf)
        JT.glLoadTransposeMatrixf((const GLfloat *)param[0].ptr);
}

void STUB_glLoadTransposeMatrixfARB( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glLoadTransposeMatrixfARB( const GLfloat * )
    maxParam = 1;
    char buffer0[16*4096];
    READ_ARRAY_PARAM( 0, buffer0, TraceReader::TEXT_FLOAT);
    TR.skipLine();
    CHECK_USER_CALL(glLoadTransposeMatrixfARB)
        UCT.glLoadTransposeMatrixfARB((const GLfloat *)param[0].ptr);
    CHECK_GL_CALL(glLoadTransposeMatrixfARB)
        JT.glLoadTransposeMatrixfARB((const GLfloat *)param[0].ptr);
}

void STUB_glLockArraysEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glLockArraysEXT( GLint, GLsizei )
    maxParam = 2;
    READ_PARAM(v32bit,0);
    READ_PARAM(v32bit,1);
    TR.skipLine();
    CHECK_USER_CALL(glLockArraysEXT)
        UCT.glLockArraysEXT(param[0].v32bit, param[1].v32bit);
    CHECK_GL_CALL(glLockArraysEXT)
        JT.glLockArraysEXT(param[0].v32bit, param[1].v32bit);
}

void STUB_glLogicOp( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glLogicOp( GLenum opcode )
    maxParam = 1;
    READ_ENUM_PARAM(0);
    TR.skipLine();
    CHECK_USER_CALL(glLogicOp)
        UCT.glLogicOp(param[0].uv32bit);
    CHECK_GL_CALL(glLogicOp)
        JT.glLogicOp(param[0].uv32bit);
}

void STUB_glMap1d( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glMap1d( GLenum target, GLdouble u1, GLdouble u2, GLint stride, GLint order, const GLdouble *points )
    maxParam = 6;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_DOUBLE_PARAM(1);
    READ_DOUBLE_PARAM(2);
    READ_PARAM(v32bit,3);
    READ_PARAM(v32bit,4);
    READ_ARRAY_PARAM( 5, buffer0, TraceReader::TEXT_DOUBLE);
    TR.skipLine();
    CHECK_USER_CALL(glMap1d)
        UCT.glMap1d(param[0].uv32bit, param[1].fv64bit, param[2].fv64bit, param[3].v32bit, param[4].v32bit, (const GLdouble *)param[5].ptr);
    CHECK_GL_CALL(glMap1d)
        JT.glMap1d(param[0].uv32bit, param[1].fv64bit, param[2].fv64bit, param[3].v32bit, param[4].v32bit, (const GLdouble *)param[5].ptr);
}

void STUB_glMap1f( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glMap1f( GLenum target, GLfloat u1, GLfloat u2, GLint stride, GLint order, const GLfloat *points )
    maxParam = 6;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_PARAM(fv32bit,1);
    READ_PARAM(fv32bit,2);
    READ_PARAM(v32bit,3);
    READ_PARAM(v32bit,4);
    READ_ARRAY_PARAM( 5, buffer0, TraceReader::TEXT_FLOAT);
    TR.skipLine();
    CHECK_USER_CALL(glMap1f)
        UCT.glMap1f(param[0].uv32bit, param[1].fv32bit, param[2].fv32bit, param[3].v32bit, param[4].v32bit, (const GLfloat *)param[5].ptr);
    CHECK_GL_CALL(glMap1f)
        JT.glMap1f(param[0].uv32bit, param[1].fv32bit, param[2].fv32bit, param[3].v32bit, param[4].v32bit, (const GLfloat *)param[5].ptr);
}

void STUB_glMap2d( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glMap2d( GLenum target, GLdouble u1, GLdouble u2, GLint ustride, GLint uorder, GLdouble v1, GLdouble v2, GLint vstride, GLint vorder, const GLdouble *points )
    maxParam = 10;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_DOUBLE_PARAM(1);
    READ_DOUBLE_PARAM(2);
    READ_PARAM(v32bit,3);
    READ_PARAM(v32bit,4);
    READ_DOUBLE_PARAM(5);
    READ_DOUBLE_PARAM(6);
    READ_PARAM(v32bit,7);
    READ_PARAM(v32bit,8);
    READ_ARRAY_PARAM( 9, buffer0, TraceReader::TEXT_DOUBLE);
    TR.skipLine();
    CHECK_USER_CALL(glMap2d)
        UCT.glMap2d(param[0].uv32bit, param[1].fv64bit, param[2].fv64bit, param[3].v32bit, param[4].v32bit, param[5].fv64bit, param[6].fv64bit, param[7].v32bit, param[8].v32bit, (const GLdouble *)param[9].ptr);
    CHECK_GL_CALL(glMap2d)
        JT.glMap2d(param[0].uv32bit, param[1].fv64bit, param[2].fv64bit, param[3].v32bit, param[4].v32bit, param[5].fv64bit, param[6].fv64bit, param[7].v32bit, param[8].v32bit, (const GLdouble *)param[9].ptr);
}

void STUB_glMap2f( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glMap2f( GLenum target, GLfloat u1, GLfloat u2, GLint ustride, GLint uorder, GLfloat v1, GLfloat v2, GLint vstride, GLint vorder, const GLfloat *points )
    maxParam = 10;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_PARAM(fv32bit,1);
    READ_PARAM(fv32bit,2);
    READ_PARAM(v32bit,3);
    READ_PARAM(v32bit,4);
    READ_PARAM(fv32bit,5);
    READ_PARAM(fv32bit,6);
    READ_PARAM(v32bit,7);
    READ_PARAM(v32bit,8);
    READ_ARRAY_PARAM( 9, buffer0, TraceReader::TEXT_FLOAT);
    TR.skipLine();
    CHECK_USER_CALL(glMap2f)
        UCT.glMap2f(param[0].uv32bit, param[1].fv32bit, param[2].fv32bit, param[3].v32bit, param[4].v32bit, param[5].fv32bit, param[6].fv32bit, param[7].v32bit, param[8].v32bit, (const GLfloat *)param[9].ptr);
    CHECK_GL_CALL(glMap2f)
        JT.glMap2f(param[0].uv32bit, param[1].fv32bit, param[2].fv32bit, param[3].v32bit, param[4].v32bit, param[5].fv32bit, param[6].fv32bit, param[7].v32bit, param[8].v32bit, (const GLfloat *)param[9].ptr);
}

void STUB_glMapBuffer( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // GLvoid *glMapBuffer( GLenum, GLenum )
    maxParam = 2;
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    TR.skipResult();
    TR.skipLine();
    CHECK_USER_CALL(glMapBuffer)
        UCT.glMapBuffer(param[0].uv32bit, param[1].uv32bit);
    CHECK_GL_CALL(glMapBuffer)
        JT.glMapBuffer(param[0].uv32bit, param[1].uv32bit);
}

void STUB_glMapBufferARB( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // GLvoid *glMapBufferARB( GLenum, GLenum )
    maxParam = 2;
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    TR.skipResult();
    TR.skipLine();
    CHECK_USER_CALL(glMapBufferARB)
        UCT.glMapBufferARB(param[0].uv32bit, param[1].uv32bit);
    CHECK_GL_CALL(glMapBufferARB)
        JT.glMapBufferARB(param[0].uv32bit, param[1].uv32bit);
}

void STUB_glMapBufferRange( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // GLvoid *glMapBufferRange( GLenum, GLintptr, GLsizeiptr, GLbitfield )
    maxParam = 4;
    READ_ENUM_PARAM(0);
    READ_PARAM(v32bit,1);
    READ_PARAM(v32bit,2);
    READ_ORING_PARAM(3);
    TR.skipResult();
    TR.skipLine();
    CHECK_USER_CALL(glMapBufferRange)
        UCT.glMapBufferRange(param[0].uv32bit, param[1].v32bit, param[2].v32bit, param[3].uv32bit);
    CHECK_GL_CALL(glMapBufferRange)
        JT.glMapBufferRange(param[0].uv32bit, param[1].v32bit, param[2].v32bit, param[3].uv32bit);
}

void STUB_glMapControlPointsNV( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glMapControlPointsNV( GLenum, GLuint, GLenum, GLsizei, GLsizei, GLint, GLint, GLboolean, const GLvoid * )
    maxParam = 9;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_ENUM_PARAM(2);
    READ_PARAM(v32bit,3);
    READ_PARAM(v32bit,4);
    READ_PARAM(v32bit,5);
    READ_PARAM(v32bit,6);
    READ_BOOLEAN_PARAM(7);
    READ_ARRAY_PARAM( 8, buffer0, TraceReader::TEXT_IGNORE);
    TR.skipLine();
    CHECK_USER_CALL(glMapControlPointsNV)
        UCT.glMapControlPointsNV(param[0].uv32bit, param[1].uv32bit, param[2].uv32bit, param[3].v32bit, param[4].v32bit, param[5].v32bit, param[6].v32bit, param[7].boolean, (const GLvoid *)param[8].ptr);
    CHECK_GL_CALL(glMapControlPointsNV)
        JT.glMapControlPointsNV(param[0].uv32bit, param[1].uv32bit, param[2].uv32bit, param[3].v32bit, param[4].v32bit, param[5].v32bit, param[6].v32bit, param[7].boolean, (const GLvoid *)param[8].ptr);
}

void STUB_glMapGrid1d( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glMapGrid1d( GLint un, GLdouble u1, GLdouble u2 )
    maxParam = 3;
    READ_PARAM(v32bit,0);
    READ_DOUBLE_PARAM(1);
    READ_DOUBLE_PARAM(2);
    TR.skipLine();
    CHECK_USER_CALL(glMapGrid1d)
        UCT.glMapGrid1d(param[0].v32bit, param[1].fv64bit, param[2].fv64bit);
    CHECK_GL_CALL(glMapGrid1d)
        JT.glMapGrid1d(param[0].v32bit, param[1].fv64bit, param[2].fv64bit);
}

void STUB_glMapGrid1f( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glMapGrid1f( GLint un, GLfloat u1, GLfloat u2 )
    maxParam = 3;
    READ_PARAM(v32bit,0);
    READ_PARAM(fv32bit,1);
    READ_PARAM(fv32bit,2);
    TR.skipLine();
    CHECK_USER_CALL(glMapGrid1f)
        UCT.glMapGrid1f(param[0].v32bit, param[1].fv32bit, param[2].fv32bit);
    CHECK_GL_CALL(glMapGrid1f)
        JT.glMapGrid1f(param[0].v32bit, param[1].fv32bit, param[2].fv32bit);
}

void STUB_glMapGrid2d( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glMapGrid2d( GLint un, GLdouble u1, GLdouble u2, GLint vn, GLdouble v1, GLdouble v2 )
    maxParam = 6;
    READ_PARAM(v32bit,0);
    READ_DOUBLE_PARAM(1);
    READ_DOUBLE_PARAM(2);
    READ_PARAM(v32bit,3);
    READ_DOUBLE_PARAM(4);
    READ_DOUBLE_PARAM(5);
    TR.skipLine();
    CHECK_USER_CALL(glMapGrid2d)
        UCT.glMapGrid2d(param[0].v32bit, param[1].fv64bit, param[2].fv64bit, param[3].v32bit, param[4].fv64bit, param[5].fv64bit);
    CHECK_GL_CALL(glMapGrid2d)
        JT.glMapGrid2d(param[0].v32bit, param[1].fv64bit, param[2].fv64bit, param[3].v32bit, param[4].fv64bit, param[5].fv64bit);
}

void STUB_glMapGrid2f( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glMapGrid2f( GLint un, GLfloat u1, GLfloat u2, GLint vn, GLfloat v1, GLfloat v2 )
    maxParam = 6;
    READ_PARAM(v32bit,0);
    READ_PARAM(fv32bit,1);
    READ_PARAM(fv32bit,2);
    READ_PARAM(v32bit,3);
    READ_PARAM(fv32bit,4);
    READ_PARAM(fv32bit,5);
    TR.skipLine();
    CHECK_USER_CALL(glMapGrid2f)
        UCT.glMapGrid2f(param[0].v32bit, param[1].fv32bit, param[2].fv32bit, param[3].v32bit, param[4].fv32bit, param[5].fv32bit);
    CHECK_GL_CALL(glMapGrid2f)
        JT.glMapGrid2f(param[0].v32bit, param[1].fv32bit, param[2].fv32bit, param[3].v32bit, param[4].fv32bit, param[5].fv32bit);
}

void STUB_glMapNamedBufferEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // GLvoid *glMapNamedBufferEXT( GLuint, GLenum )
    maxParam = 2;
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    TR.skipResult();
    TR.skipLine();
    CHECK_USER_CALL(glMapNamedBufferEXT)
        UCT.glMapNamedBufferEXT(param[0].uv32bit, param[1].uv32bit);
    CHECK_GL_CALL(glMapNamedBufferEXT)
        JT.glMapNamedBufferEXT(param[0].uv32bit, param[1].uv32bit);
}

void STUB_glMapObjectBufferATI( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // GLvoid *glMapObjectBufferATI( GLuint )
    maxParam = 1;
    READ_ENUM_PARAM(0);
    TR.skipResult();
    TR.skipLine();
    CHECK_USER_CALL(glMapObjectBufferATI)
        UCT.glMapObjectBufferATI(param[0].uv32bit);
    CHECK_GL_CALL(glMapObjectBufferATI)
        JT.glMapObjectBufferATI(param[0].uv32bit);
}

void STUB_glMapParameterfvNV( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glMapParameterfvNV( GLenum, GLenum, const GLfloat * )
    maxParam = 3;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_ARRAY_PARAM( 2, buffer0, TraceReader::TEXT_FLOAT);
    TR.skipLine();
    CHECK_USER_CALL(glMapParameterfvNV)
        UCT.glMapParameterfvNV(param[0].uv32bit, param[1].uv32bit, (const GLfloat *)param[2].ptr);
    CHECK_GL_CALL(glMapParameterfvNV)
        JT.glMapParameterfvNV(param[0].uv32bit, param[1].uv32bit, (const GLfloat *)param[2].ptr);
}

void STUB_glMapParameterivNV( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glMapParameterivNV( GLenum, GLenum, const GLint * )
    maxParam = 3;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_ARRAY_PARAM( 2, buffer0, TraceReader::TEXT_INT);
    TR.skipLine();
    CHECK_USER_CALL(glMapParameterivNV)
        UCT.glMapParameterivNV(param[0].uv32bit, param[1].uv32bit, (const GLint *)param[2].ptr);
    CHECK_GL_CALL(glMapParameterivNV)
        JT.glMapParameterivNV(param[0].uv32bit, param[1].uv32bit, (const GLint *)param[2].ptr);
}

void STUB_glMaterialf( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glMaterialf( GLenum face, GLenum pname, GLfloat param )
    maxParam = 3;
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_PARAM(fv32bit,2);
    TR.skipLine();
    CHECK_USER_CALL(glMaterialf)
        UCT.glMaterialf(param[0].uv32bit, param[1].uv32bit, param[2].fv32bit);
    CHECK_GL_CALL(glMaterialf)
        JT.glMaterialf(param[0].uv32bit, param[1].uv32bit, param[2].fv32bit);
}

void STUB_glMaterialfv( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glMaterialfv( GLenum face, GLenum pname, const GLfloat *params )
    maxParam = 3;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_ARRAY_PARAM( 2, buffer0, TraceReader::TEXT_FLOAT);
    TR.skipLine();
    CHECK_USER_CALL(glMaterialfv)
        UCT.glMaterialfv(param[0].uv32bit, param[1].uv32bit, (const GLfloat *)param[2].ptr);
    CHECK_GL_CALL(glMaterialfv)
        JT.glMaterialfv(param[0].uv32bit, param[1].uv32bit, (const GLfloat *)param[2].ptr);
}

void STUB_glMateriali( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glMateriali( GLenum face, GLenum pname, GLint param )
    maxParam = 3;
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_PARAM(v32bit,2);
    TR.skipLine();
    CHECK_USER_CALL(glMateriali)
        UCT.glMateriali(param[0].uv32bit, param[1].uv32bit, param[2].v32bit);
    CHECK_GL_CALL(glMateriali)
        JT.glMateriali(param[0].uv32bit, param[1].uv32bit, param[2].v32bit);
}

void STUB_glMaterialiv( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glMaterialiv( GLenum face, GLenum pname, const GLint *params )
    maxParam = 3;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_ARRAY_PARAM( 2, buffer0, TraceReader::TEXT_INT);
    TR.skipLine();
    CHECK_USER_CALL(glMaterialiv)
        UCT.glMaterialiv(param[0].uv32bit, param[1].uv32bit, (const GLint *)param[2].ptr);
    CHECK_GL_CALL(glMaterialiv)
        JT.glMaterialiv(param[0].uv32bit, param[1].uv32bit, (const GLint *)param[2].ptr);
}

void STUB_glMatrixFrustumEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glMatrixFrustumEXT( GLenum, GLdouble, GLdouble, GLdouble, GLdouble, GLdouble, GLdouble )
    maxParam = 7;
    READ_ENUM_PARAM(0);
    READ_DOUBLE_PARAM(1);
    READ_DOUBLE_PARAM(2);
    READ_DOUBLE_PARAM(3);
    READ_DOUBLE_PARAM(4);
    READ_DOUBLE_PARAM(5);
    READ_DOUBLE_PARAM(6);
    TR.skipLine();
    CHECK_USER_CALL(glMatrixFrustumEXT)
        UCT.glMatrixFrustumEXT(param[0].uv32bit, param[1].fv64bit, param[2].fv64bit, param[3].fv64bit, param[4].fv64bit, param[5].fv64bit, param[6].fv64bit);
    CHECK_GL_CALL(glMatrixFrustumEXT)
        JT.glMatrixFrustumEXT(param[0].uv32bit, param[1].fv64bit, param[2].fv64bit, param[3].fv64bit, param[4].fv64bit, param[5].fv64bit, param[6].fv64bit);
}

void STUB_glMatrixIndexPointerARB( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glMatrixIndexPointerARB( GLint, GLenum, GLsizei, const GLvoid * )
    maxParam = 4;
    char buffer0[16*4096];
    READ_PARAM(v32bit,0);
    READ_ENUM_PARAM(1);
    READ_PARAM(v32bit,2);
    READ_ARRAY_PARAM( 3, buffer0, TraceReader::TEXT_IGNORE);
    TR.skipLine();
    CHECK_USER_CALL(glMatrixIndexPointerARB)
        UCT.glMatrixIndexPointerARB(param[0].v32bit, param[1].uv32bit, param[2].v32bit, (const GLvoid *)param[3].ptr);
    CHECK_GL_CALL(glMatrixIndexPointerARB)
        JT.glMatrixIndexPointerARB(param[0].v32bit, param[1].uv32bit, param[2].v32bit, (const GLvoid *)param[3].ptr);
}

void STUB_glMatrixIndexubvARB( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glMatrixIndexubvARB( GLint, const GLubyte * )
    maxParam = 2;
    char buffer0[16*4096];
    READ_PARAM(v32bit,0);
    READ_ARRAY_PARAM( 1, buffer0, TraceReader::TEXT_BYTE);
    TR.skipLine();
    CHECK_USER_CALL(glMatrixIndexubvARB)
        UCT.glMatrixIndexubvARB(param[0].v32bit, (const GLubyte *)param[1].ptr);
    CHECK_GL_CALL(glMatrixIndexubvARB)
        JT.glMatrixIndexubvARB(param[0].v32bit, (const GLubyte *)param[1].ptr);
}

void STUB_glMatrixIndexuivARB( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glMatrixIndexuivARB( GLint, const GLuint * )
    maxParam = 2;
    char buffer0[16*4096];
    READ_PARAM(v32bit,0);
    READ_ARRAY_PARAM( 1, buffer0, TraceReader::TEXT_INT);
    TR.skipLine();
    CHECK_USER_CALL(glMatrixIndexuivARB)
        UCT.glMatrixIndexuivARB(param[0].v32bit, (const GLuint *)param[1].ptr);
    CHECK_GL_CALL(glMatrixIndexuivARB)
        JT.glMatrixIndexuivARB(param[0].v32bit, (const GLuint *)param[1].ptr);
}

void STUB_glMatrixIndexusvARB( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glMatrixIndexusvARB( GLint, const GLushort * )
    maxParam = 2;
    char buffer0[16*4096];
    READ_PARAM(v32bit,0);
    READ_ARRAY_PARAM( 1, buffer0, TraceReader::TEXT_SHORT);
    TR.skipLine();
    CHECK_USER_CALL(glMatrixIndexusvARB)
        UCT.glMatrixIndexusvARB(param[0].v32bit, (const GLushort *)param[1].ptr);
    CHECK_GL_CALL(glMatrixIndexusvARB)
        JT.glMatrixIndexusvARB(param[0].v32bit, (const GLushort *)param[1].ptr);
}

void STUB_glMatrixLoadIdentityEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glMatrixLoadIdentityEXT( GLenum )
    maxParam = 1;
    READ_ENUM_PARAM(0);
    TR.skipLine();
    CHECK_USER_CALL(glMatrixLoadIdentityEXT)
        UCT.glMatrixLoadIdentityEXT(param[0].uv32bit);
    CHECK_GL_CALL(glMatrixLoadIdentityEXT)
        JT.glMatrixLoadIdentityEXT(param[0].uv32bit);
}

void STUB_glMatrixLoadTransposedEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glMatrixLoadTransposedEXT( GLenum, const GLdouble * )
    maxParam = 2;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ARRAY_PARAM( 1, buffer0, TraceReader::TEXT_DOUBLE);
    TR.skipLine();
    CHECK_USER_CALL(glMatrixLoadTransposedEXT)
        UCT.glMatrixLoadTransposedEXT(param[0].uv32bit, (const GLdouble *)param[1].ptr);
    CHECK_GL_CALL(glMatrixLoadTransposedEXT)
        JT.glMatrixLoadTransposedEXT(param[0].uv32bit, (const GLdouble *)param[1].ptr);
}

void STUB_glMatrixLoadTransposefEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glMatrixLoadTransposefEXT( GLenum, const GLfloat * )
    maxParam = 2;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ARRAY_PARAM( 1, buffer0, TraceReader::TEXT_FLOAT);
    TR.skipLine();
    CHECK_USER_CALL(glMatrixLoadTransposefEXT)
        UCT.glMatrixLoadTransposefEXT(param[0].uv32bit, (const GLfloat *)param[1].ptr);
    CHECK_GL_CALL(glMatrixLoadTransposefEXT)
        JT.glMatrixLoadTransposefEXT(param[0].uv32bit, (const GLfloat *)param[1].ptr);
}

void STUB_glMatrixLoaddEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glMatrixLoaddEXT( GLenum, const GLdouble * )
    maxParam = 2;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ARRAY_PARAM( 1, buffer0, TraceReader::TEXT_DOUBLE);
    TR.skipLine();
    CHECK_USER_CALL(glMatrixLoaddEXT)
        UCT.glMatrixLoaddEXT(param[0].uv32bit, (const GLdouble *)param[1].ptr);
    CHECK_GL_CALL(glMatrixLoaddEXT)
        JT.glMatrixLoaddEXT(param[0].uv32bit, (const GLdouble *)param[1].ptr);
}

void STUB_glMatrixLoadfEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glMatrixLoadfEXT( GLenum, const GLfloat * )
    maxParam = 2;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ARRAY_PARAM( 1, buffer0, TraceReader::TEXT_FLOAT);
    TR.skipLine();
    CHECK_USER_CALL(glMatrixLoadfEXT)
        UCT.glMatrixLoadfEXT(param[0].uv32bit, (const GLfloat *)param[1].ptr);
    CHECK_GL_CALL(glMatrixLoadfEXT)
        JT.glMatrixLoadfEXT(param[0].uv32bit, (const GLfloat *)param[1].ptr);
}

void STUB_glMatrixMode( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glMatrixMode( GLenum mode )
    maxParam = 1;
    READ_ENUM_PARAM(0);
    TR.skipLine();
    CHECK_USER_CALL(glMatrixMode)
        UCT.glMatrixMode(param[0].uv32bit);
    CHECK_GL_CALL(glMatrixMode)
        JT.glMatrixMode(param[0].uv32bit);
}

void STUB_glMatrixMultTransposedEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glMatrixMultTransposedEXT( GLenum, const GLdouble * )
    maxParam = 2;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ARRAY_PARAM( 1, buffer0, TraceReader::TEXT_DOUBLE);
    TR.skipLine();
    CHECK_USER_CALL(glMatrixMultTransposedEXT)
        UCT.glMatrixMultTransposedEXT(param[0].uv32bit, (const GLdouble *)param[1].ptr);
    CHECK_GL_CALL(glMatrixMultTransposedEXT)
        JT.glMatrixMultTransposedEXT(param[0].uv32bit, (const GLdouble *)param[1].ptr);
}

void STUB_glMatrixMultTransposefEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glMatrixMultTransposefEXT( GLenum, const GLfloat * )
    maxParam = 2;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ARRAY_PARAM( 1, buffer0, TraceReader::TEXT_FLOAT);
    TR.skipLine();
    CHECK_USER_CALL(glMatrixMultTransposefEXT)
        UCT.glMatrixMultTransposefEXT(param[0].uv32bit, (const GLfloat *)param[1].ptr);
    CHECK_GL_CALL(glMatrixMultTransposefEXT)
        JT.glMatrixMultTransposefEXT(param[0].uv32bit, (const GLfloat *)param[1].ptr);
}

void STUB_glMatrixMultdEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glMatrixMultdEXT( GLenum, const GLdouble * )
    maxParam = 2;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ARRAY_PARAM( 1, buffer0, TraceReader::TEXT_DOUBLE);
    TR.skipLine();
    CHECK_USER_CALL(glMatrixMultdEXT)
        UCT.glMatrixMultdEXT(param[0].uv32bit, (const GLdouble *)param[1].ptr);
    CHECK_GL_CALL(glMatrixMultdEXT)
        JT.glMatrixMultdEXT(param[0].uv32bit, (const GLdouble *)param[1].ptr);
}

void STUB_glMatrixMultfEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glMatrixMultfEXT( GLenum, const GLfloat * )
    maxParam = 2;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ARRAY_PARAM( 1, buffer0, TraceReader::TEXT_FLOAT);
    TR.skipLine();
    CHECK_USER_CALL(glMatrixMultfEXT)
        UCT.glMatrixMultfEXT(param[0].uv32bit, (const GLfloat *)param[1].ptr);
    CHECK_GL_CALL(glMatrixMultfEXT)
        JT.glMatrixMultfEXT(param[0].uv32bit, (const GLfloat *)param[1].ptr);
}

void STUB_glMatrixOrthoEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glMatrixOrthoEXT( GLenum, GLdouble, GLdouble, GLdouble, GLdouble, GLdouble, GLdouble )
    maxParam = 7;
    READ_ENUM_PARAM(0);
    READ_DOUBLE_PARAM(1);
    READ_DOUBLE_PARAM(2);
    READ_DOUBLE_PARAM(3);
    READ_DOUBLE_PARAM(4);
    READ_DOUBLE_PARAM(5);
    READ_DOUBLE_PARAM(6);
    TR.skipLine();
    CHECK_USER_CALL(glMatrixOrthoEXT)
        UCT.glMatrixOrthoEXT(param[0].uv32bit, param[1].fv64bit, param[2].fv64bit, param[3].fv64bit, param[4].fv64bit, param[5].fv64bit, param[6].fv64bit);
    CHECK_GL_CALL(glMatrixOrthoEXT)
        JT.glMatrixOrthoEXT(param[0].uv32bit, param[1].fv64bit, param[2].fv64bit, param[3].fv64bit, param[4].fv64bit, param[5].fv64bit, param[6].fv64bit);
}

void STUB_glMatrixPopEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glMatrixPopEXT( GLenum )
    maxParam = 1;
    READ_ENUM_PARAM(0);
    TR.skipLine();
    CHECK_USER_CALL(glMatrixPopEXT)
        UCT.glMatrixPopEXT(param[0].uv32bit);
    CHECK_GL_CALL(glMatrixPopEXT)
        JT.glMatrixPopEXT(param[0].uv32bit);
}

void STUB_glMatrixPushEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glMatrixPushEXT( GLenum )
    maxParam = 1;
    READ_ENUM_PARAM(0);
    TR.skipLine();
    CHECK_USER_CALL(glMatrixPushEXT)
        UCT.glMatrixPushEXT(param[0].uv32bit);
    CHECK_GL_CALL(glMatrixPushEXT)
        JT.glMatrixPushEXT(param[0].uv32bit);
}

void STUB_glMatrixRotatedEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glMatrixRotatedEXT( GLenum, GLdouble, GLdouble, GLdouble, GLdouble )
    maxParam = 5;
    READ_ENUM_PARAM(0);
    READ_DOUBLE_PARAM(1);
    READ_DOUBLE_PARAM(2);
    READ_DOUBLE_PARAM(3);
    READ_DOUBLE_PARAM(4);
    TR.skipLine();
    CHECK_USER_CALL(glMatrixRotatedEXT)
        UCT.glMatrixRotatedEXT(param[0].uv32bit, param[1].fv64bit, param[2].fv64bit, param[3].fv64bit, param[4].fv64bit);
    CHECK_GL_CALL(glMatrixRotatedEXT)
        JT.glMatrixRotatedEXT(param[0].uv32bit, param[1].fv64bit, param[2].fv64bit, param[3].fv64bit, param[4].fv64bit);
}

void STUB_glMatrixRotatefEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glMatrixRotatefEXT( GLenum, GLfloat, GLfloat, GLfloat, GLfloat )
    maxParam = 5;
    READ_ENUM_PARAM(0);
    READ_PARAM(fv32bit,1);
    READ_PARAM(fv32bit,2);
    READ_PARAM(fv32bit,3);
    READ_PARAM(fv32bit,4);
    TR.skipLine();
    CHECK_USER_CALL(glMatrixRotatefEXT)
        UCT.glMatrixRotatefEXT(param[0].uv32bit, param[1].fv32bit, param[2].fv32bit, param[3].fv32bit, param[4].fv32bit);
    CHECK_GL_CALL(glMatrixRotatefEXT)
        JT.glMatrixRotatefEXT(param[0].uv32bit, param[1].fv32bit, param[2].fv32bit, param[3].fv32bit, param[4].fv32bit);
}

void STUB_glMatrixScaledEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glMatrixScaledEXT( GLenum, GLdouble, GLdouble, GLdouble )
    maxParam = 4;
    READ_ENUM_PARAM(0);
    READ_DOUBLE_PARAM(1);
    READ_DOUBLE_PARAM(2);
    READ_DOUBLE_PARAM(3);
    TR.skipLine();
    CHECK_USER_CALL(glMatrixScaledEXT)
        UCT.glMatrixScaledEXT(param[0].uv32bit, param[1].fv64bit, param[2].fv64bit, param[3].fv64bit);
    CHECK_GL_CALL(glMatrixScaledEXT)
        JT.glMatrixScaledEXT(param[0].uv32bit, param[1].fv64bit, param[2].fv64bit, param[3].fv64bit);
}

void STUB_glMatrixScalefEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glMatrixScalefEXT( GLenum, GLfloat, GLfloat, GLfloat )
    maxParam = 4;
    READ_ENUM_PARAM(0);
    READ_PARAM(fv32bit,1);
    READ_PARAM(fv32bit,2);
    READ_PARAM(fv32bit,3);
    TR.skipLine();
    CHECK_USER_CALL(glMatrixScalefEXT)
        UCT.glMatrixScalefEXT(param[0].uv32bit, param[1].fv32bit, param[2].fv32bit, param[3].fv32bit);
    CHECK_GL_CALL(glMatrixScalefEXT)
        JT.glMatrixScalefEXT(param[0].uv32bit, param[1].fv32bit, param[2].fv32bit, param[3].fv32bit);
}

void STUB_glMatrixTranslatedEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glMatrixTranslatedEXT( GLenum, GLdouble, GLdouble, GLdouble )
    maxParam = 4;
    READ_ENUM_PARAM(0);
    READ_DOUBLE_PARAM(1);
    READ_DOUBLE_PARAM(2);
    READ_DOUBLE_PARAM(3);
    TR.skipLine();
    CHECK_USER_CALL(glMatrixTranslatedEXT)
        UCT.glMatrixTranslatedEXT(param[0].uv32bit, param[1].fv64bit, param[2].fv64bit, param[3].fv64bit);
    CHECK_GL_CALL(glMatrixTranslatedEXT)
        JT.glMatrixTranslatedEXT(param[0].uv32bit, param[1].fv64bit, param[2].fv64bit, param[3].fv64bit);
}

void STUB_glMatrixTranslatefEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glMatrixTranslatefEXT( GLenum, GLfloat, GLfloat, GLfloat )
    maxParam = 4;
    READ_ENUM_PARAM(0);
    READ_PARAM(fv32bit,1);
    READ_PARAM(fv32bit,2);
    READ_PARAM(fv32bit,3);
    TR.skipLine();
    CHECK_USER_CALL(glMatrixTranslatefEXT)
        UCT.glMatrixTranslatefEXT(param[0].uv32bit, param[1].fv32bit, param[2].fv32bit, param[3].fv32bit);
    CHECK_GL_CALL(glMatrixTranslatefEXT)
        JT.glMatrixTranslatefEXT(param[0].uv32bit, param[1].fv32bit, param[2].fv32bit, param[3].fv32bit);
}

void STUB_glMinmax( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glMinmax( GLenum target, GLenum internalformat, GLboolean sink )
    maxParam = 3;
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_BOOLEAN_PARAM(2);
    TR.skipLine();
    CHECK_USER_CALL(glMinmax)
        UCT.glMinmax(param[0].uv32bit, param[1].uv32bit, param[2].boolean);
    CHECK_GL_CALL(glMinmax)
        JT.glMinmax(param[0].uv32bit, param[1].uv32bit, param[2].boolean);
}

void STUB_glMinmaxEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glMinmaxEXT( GLenum, GLenum, GLboolean )
    maxParam = 3;
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_BOOLEAN_PARAM(2);
    TR.skipLine();
    CHECK_USER_CALL(glMinmaxEXT)
        UCT.glMinmaxEXT(param[0].uv32bit, param[1].uv32bit, param[2].boolean);
    CHECK_GL_CALL(glMinmaxEXT)
        JT.glMinmaxEXT(param[0].uv32bit, param[1].uv32bit, param[2].boolean);
}

void STUB_glMultMatrixd( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glMultMatrixd( const GLdouble *m )
    maxParam = 1;
    char buffer0[16*4096];
    READ_ARRAY_PARAM( 0, buffer0, TraceReader::TEXT_DOUBLE);
    TR.skipLine();
    CHECK_USER_CALL(glMultMatrixd)
        UCT.glMultMatrixd((const GLdouble *)param[0].ptr);
    CHECK_GL_CALL(glMultMatrixd)
        JT.glMultMatrixd((const GLdouble *)param[0].ptr);
}

void STUB_glMultMatrixf( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glMultMatrixf( const GLfloat *m )
    maxParam = 1;
    char buffer0[16*4096];
    READ_ARRAY_PARAM( 0, buffer0, TraceReader::TEXT_FLOAT);
    TR.skipLine();
    CHECK_USER_CALL(glMultMatrixf)
        UCT.glMultMatrixf((const GLfloat *)param[0].ptr);
    CHECK_GL_CALL(glMultMatrixf)
        JT.glMultMatrixf((const GLfloat *)param[0].ptr);
}

void STUB_glMultTransposeMatrixd( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glMultTransposeMatrixd( const GLdouble *m )
    maxParam = 1;
    char buffer0[16*4096];
    READ_ARRAY_PARAM( 0, buffer0, TraceReader::TEXT_DOUBLE);
    TR.skipLine();
    CHECK_USER_CALL(glMultTransposeMatrixd)
        UCT.glMultTransposeMatrixd((const GLdouble *)param[0].ptr);
    CHECK_GL_CALL(glMultTransposeMatrixd)
        JT.glMultTransposeMatrixd((const GLdouble *)param[0].ptr);
}

void STUB_glMultTransposeMatrixdARB( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glMultTransposeMatrixdARB( const GLdouble * )
    maxParam = 1;
    char buffer0[16*4096];
    READ_ARRAY_PARAM( 0, buffer0, TraceReader::TEXT_DOUBLE);
    TR.skipLine();
    CHECK_USER_CALL(glMultTransposeMatrixdARB)
        UCT.glMultTransposeMatrixdARB((const GLdouble *)param[0].ptr);
    CHECK_GL_CALL(glMultTransposeMatrixdARB)
        JT.glMultTransposeMatrixdARB((const GLdouble *)param[0].ptr);
}

void STUB_glMultTransposeMatrixf( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glMultTransposeMatrixf( const GLfloat *m )
    maxParam = 1;
    char buffer0[16*4096];
    READ_ARRAY_PARAM( 0, buffer0, TraceReader::TEXT_FLOAT);
    TR.skipLine();
    CHECK_USER_CALL(glMultTransposeMatrixf)
        UCT.glMultTransposeMatrixf((const GLfloat *)param[0].ptr);
    CHECK_GL_CALL(glMultTransposeMatrixf)
        JT.glMultTransposeMatrixf((const GLfloat *)param[0].ptr);
}

void STUB_glMultTransposeMatrixfARB( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glMultTransposeMatrixfARB( const GLfloat * )
    maxParam = 1;
    char buffer0[16*4096];
    READ_ARRAY_PARAM( 0, buffer0, TraceReader::TEXT_FLOAT);
    TR.skipLine();
    CHECK_USER_CALL(glMultTransposeMatrixfARB)
        UCT.glMultTransposeMatrixfARB((const GLfloat *)param[0].ptr);
    CHECK_GL_CALL(glMultTransposeMatrixfARB)
        JT.glMultTransposeMatrixfARB((const GLfloat *)param[0].ptr);
}

void STUB_glMultiDrawArrays( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glMultiDrawArrays( GLenum, GLint *, GLsizei *, GLsizei )
    maxParam = 4;
    char buffer0[16*4096];
    char buffer1[16*4096];
    READ_ENUM_PARAM(0);
    READ_ARRAY_PARAM( 1, buffer0, TraceReader::TEXT_INT);
    READ_ARRAY_PARAM( 2, buffer1, TraceReader::TEXT_INT);
    READ_PARAM(v32bit,3);
    TR.skipLine();
    CHECK_USER_CALL(glMultiDrawArrays)
        UCT.glMultiDrawArrays(param[0].uv32bit, (GLint *)param[1].ptr, (GLsizei *)param[2].ptr, param[3].v32bit);
    CHECK_GL_CALL(glMultiDrawArrays)
        JT.glMultiDrawArrays(param[0].uv32bit, (GLint *)param[1].ptr, (GLsizei *)param[2].ptr, param[3].v32bit);
}

void STUB_glMultiDrawArraysEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glMultiDrawArraysEXT( GLenum, GLint *, GLsizei *, GLsizei )
    maxParam = 4;
    char buffer0[16*4096];
    char buffer1[16*4096];
    READ_ENUM_PARAM(0);
    READ_ARRAY_PARAM( 1, buffer0, TraceReader::TEXT_INT);
    READ_ARRAY_PARAM( 2, buffer1, TraceReader::TEXT_INT);
    READ_PARAM(v32bit,3);
    TR.skipLine();
    CHECK_USER_CALL(glMultiDrawArraysEXT)
        UCT.glMultiDrawArraysEXT(param[0].uv32bit, (GLint *)param[1].ptr, (GLsizei *)param[2].ptr, param[3].v32bit);
    CHECK_GL_CALL(glMultiDrawArraysEXT)
        JT.glMultiDrawArraysEXT(param[0].uv32bit, (GLint *)param[1].ptr, (GLsizei *)param[2].ptr, param[3].v32bit);
}

void STUB_glMultiDrawElementArrayAPPLE( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glMultiDrawElementArrayAPPLE( GLenum, const GLint *, const GLsizei *, GLsizei )
    maxParam = 4;
    char buffer0[16*4096];
    char buffer1[16*4096];
    READ_ENUM_PARAM(0);
    READ_ARRAY_PARAM( 1, buffer0, TraceReader::TEXT_INT);
    READ_ARRAY_PARAM( 2, buffer1, TraceReader::TEXT_INT);
    READ_PARAM(v32bit,3);
    TR.skipLine();
    CHECK_USER_CALL(glMultiDrawElementArrayAPPLE)
        UCT.glMultiDrawElementArrayAPPLE(param[0].uv32bit, (const GLint *)param[1].ptr, (const GLsizei *)param[2].ptr, param[3].v32bit);
    CHECK_GL_CALL(glMultiDrawElementArrayAPPLE)
        JT.glMultiDrawElementArrayAPPLE(param[0].uv32bit, (const GLint *)param[1].ptr, (const GLsizei *)param[2].ptr, param[3].v32bit);
}

void STUB_glMultiDrawElements( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glMultiDrawElements( GLenum, const GLsizei *, GLenum, const GLvoid **, GLsizei )
    maxParam = 5;
    char buffer0[16*4096];
    char buffer1[16*4096];
    READ_ENUM_PARAM(0);
    READ_ARRAY_PARAM( 1, buffer0, TraceReader::TEXT_INT);
    READ_ENUM_PARAM(2);
    READ_ARRAY_PARAM( 3, buffer1, TraceReader::TEXT_IGNORE);
    READ_PARAM(v32bit,4);
    TR.skipLine();
    CHECK_USER_CALL(glMultiDrawElements)
        UCT.glMultiDrawElements(param[0].uv32bit, (const GLsizei *)param[1].ptr, param[2].uv32bit, (const GLvoid **)param[3].ptr, param[4].v32bit);
    CHECK_GL_CALL(glMultiDrawElements)
        JT.glMultiDrawElements(param[0].uv32bit, (const GLsizei *)param[1].ptr, param[2].uv32bit, (const GLvoid **)param[3].ptr, param[4].v32bit);
}

void STUB_glMultiDrawElementsEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glMultiDrawElementsEXT( GLenum, const GLsizei *, GLenum, const GLvoid **, GLsizei )
    maxParam = 5;
    char buffer0[16*4096];
    char buffer1[16*4096];
    READ_ENUM_PARAM(0);
    READ_ARRAY_PARAM( 1, buffer0, TraceReader::TEXT_INT);
    READ_ENUM_PARAM(2);
    READ_ARRAY_PARAM( 3, buffer1, TraceReader::TEXT_IGNORE);
    READ_PARAM(v32bit,4);
    TR.skipLine();
    CHECK_USER_CALL(glMultiDrawElementsEXT)
        UCT.glMultiDrawElementsEXT(param[0].uv32bit, (const GLsizei *)param[1].ptr, param[2].uv32bit, (const GLvoid **)param[3].ptr, param[4].v32bit);
    CHECK_GL_CALL(glMultiDrawElementsEXT)
        JT.glMultiDrawElementsEXT(param[0].uv32bit, (const GLsizei *)param[1].ptr, param[2].uv32bit, (const GLvoid **)param[3].ptr, param[4].v32bit);
}

void STUB_glMultiDrawRangeElementArrayAPPLE( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glMultiDrawRangeElementArrayAPPLE( GLenum, GLuint, GLuint, const GLint *, const GLsizei *, GLsizei )
    maxParam = 6;
    char buffer0[16*4096];
    char buffer1[16*4096];
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_ENUM_PARAM(2);
    READ_ARRAY_PARAM( 3, buffer0, TraceReader::TEXT_INT);
    READ_ARRAY_PARAM( 4, buffer1, TraceReader::TEXT_INT);
    READ_PARAM(v32bit,5);
    TR.skipLine();
    CHECK_USER_CALL(glMultiDrawRangeElementArrayAPPLE)
        UCT.glMultiDrawRangeElementArrayAPPLE(param[0].uv32bit, param[1].uv32bit, param[2].uv32bit, (const GLint *)param[3].ptr, (const GLsizei *)param[4].ptr, param[5].v32bit);
    CHECK_GL_CALL(glMultiDrawRangeElementArrayAPPLE)
        JT.glMultiDrawRangeElementArrayAPPLE(param[0].uv32bit, param[1].uv32bit, param[2].uv32bit, (const GLint *)param[3].ptr, (const GLsizei *)param[4].ptr, param[5].v32bit);
}

void STUB_glMultiTexBufferEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glMultiTexBufferEXT( GLenum, GLenum, GLenum, GLuint )
    maxParam = 4;
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_ENUM_PARAM(2);
    READ_ENUM_PARAM(3);
    TR.skipLine();
    CHECK_USER_CALL(glMultiTexBufferEXT)
        UCT.glMultiTexBufferEXT(param[0].uv32bit, param[1].uv32bit, param[2].uv32bit, param[3].uv32bit);
    CHECK_GL_CALL(glMultiTexBufferEXT)
        JT.glMultiTexBufferEXT(param[0].uv32bit, param[1].uv32bit, param[2].uv32bit, param[3].uv32bit);
}

void STUB_glMultiTexCoord1d( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glMultiTexCoord1d( GLenum target, GLdouble s )
    maxParam = 2;
    READ_ENUM_PARAM(0);
    READ_DOUBLE_PARAM(1);
    TR.skipLine();
    CHECK_USER_CALL(glMultiTexCoord1d)
        UCT.glMultiTexCoord1d(param[0].uv32bit, param[1].fv64bit);
    CHECK_GL_CALL(glMultiTexCoord1d)
        JT.glMultiTexCoord1d(param[0].uv32bit, param[1].fv64bit);
}

void STUB_glMultiTexCoord1dARB( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glMultiTexCoord1dARB( GLenum target, GLdouble s )
    maxParam = 2;
    READ_ENUM_PARAM(0);
    READ_DOUBLE_PARAM(1);
    TR.skipLine();
    CHECK_USER_CALL(glMultiTexCoord1dARB)
        UCT.glMultiTexCoord1dARB(param[0].uv32bit, param[1].fv64bit);
    CHECK_GL_CALL(glMultiTexCoord1dARB)
        JT.glMultiTexCoord1dARB(param[0].uv32bit, param[1].fv64bit);
}

void STUB_glMultiTexCoord1dv( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glMultiTexCoord1dv( GLenum target, const GLdouble *v )
    maxParam = 2;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ARRAY_PARAM( 1, buffer0, TraceReader::TEXT_DOUBLE);
    TR.skipLine();
    CHECK_USER_CALL(glMultiTexCoord1dv)
        UCT.glMultiTexCoord1dv(param[0].uv32bit, (const GLdouble *)param[1].ptr);
    CHECK_GL_CALL(glMultiTexCoord1dv)
        JT.glMultiTexCoord1dv(param[0].uv32bit, (const GLdouble *)param[1].ptr);
}

void STUB_glMultiTexCoord1dvARB( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glMultiTexCoord1dvARB( GLenum target, const GLdouble *v )
    maxParam = 2;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ARRAY_PARAM( 1, buffer0, TraceReader::TEXT_DOUBLE);
    TR.skipLine();
    CHECK_USER_CALL(glMultiTexCoord1dvARB)
        UCT.glMultiTexCoord1dvARB(param[0].uv32bit, (const GLdouble *)param[1].ptr);
    CHECK_GL_CALL(glMultiTexCoord1dvARB)
        JT.glMultiTexCoord1dvARB(param[0].uv32bit, (const GLdouble *)param[1].ptr);
}

void STUB_glMultiTexCoord1f( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glMultiTexCoord1f( GLenum target, GLfloat s )
    maxParam = 2;
    READ_ENUM_PARAM(0);
    READ_PARAM(fv32bit,1);
    TR.skipLine();
    CHECK_USER_CALL(glMultiTexCoord1f)
        UCT.glMultiTexCoord1f(param[0].uv32bit, param[1].fv32bit);
    CHECK_GL_CALL(glMultiTexCoord1f)
        JT.glMultiTexCoord1f(param[0].uv32bit, param[1].fv32bit);
}

void STUB_glMultiTexCoord1fARB( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glMultiTexCoord1fARB( GLenum target, GLfloat s )
    maxParam = 2;
    READ_ENUM_PARAM(0);
    READ_PARAM(fv32bit,1);
    TR.skipLine();
    CHECK_USER_CALL(glMultiTexCoord1fARB)
        UCT.glMultiTexCoord1fARB(param[0].uv32bit, param[1].fv32bit);
    CHECK_GL_CALL(glMultiTexCoord1fARB)
        JT.glMultiTexCoord1fARB(param[0].uv32bit, param[1].fv32bit);
}

void STUB_glMultiTexCoord1fv( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glMultiTexCoord1fv( GLenum target, const GLfloat *v )
    maxParam = 2;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ARRAY_PARAM( 1, buffer0, TraceReader::TEXT_FLOAT);
    TR.skipLine();
    CHECK_USER_CALL(glMultiTexCoord1fv)
        UCT.glMultiTexCoord1fv(param[0].uv32bit, (const GLfloat *)param[1].ptr);
    CHECK_GL_CALL(glMultiTexCoord1fv)
        JT.glMultiTexCoord1fv(param[0].uv32bit, (const GLfloat *)param[1].ptr);
}

void STUB_glMultiTexCoord1fvARB( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glMultiTexCoord1fvARB( GLenum target, const GLfloat *v )
    maxParam = 2;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ARRAY_PARAM( 1, buffer0, TraceReader::TEXT_FLOAT);
    TR.skipLine();
    CHECK_USER_CALL(glMultiTexCoord1fvARB)
        UCT.glMultiTexCoord1fvARB(param[0].uv32bit, (const GLfloat *)param[1].ptr);
    CHECK_GL_CALL(glMultiTexCoord1fvARB)
        JT.glMultiTexCoord1fvARB(param[0].uv32bit, (const GLfloat *)param[1].ptr);
}

void STUB_glMultiTexCoord1hNV( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glMultiTexCoord1hNV( GLenum, GLhalfNV )
    // Call not playable
    TR.skipCall();
}

void STUB_glMultiTexCoord1hvNV( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glMultiTexCoord1hvNV( GLenum, const GLhalfNV * )
    // Call not playable
    TR.skipCall();
}

void STUB_glMultiTexCoord1i( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glMultiTexCoord1i( GLenum target, GLint s )
    maxParam = 2;
    READ_ENUM_PARAM(0);
    READ_PARAM(v32bit,1);
    TR.skipLine();
    CHECK_USER_CALL(glMultiTexCoord1i)
        UCT.glMultiTexCoord1i(param[0].uv32bit, param[1].v32bit);
    CHECK_GL_CALL(glMultiTexCoord1i)
        JT.glMultiTexCoord1i(param[0].uv32bit, param[1].v32bit);
}

void STUB_glMultiTexCoord1iARB( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glMultiTexCoord1iARB( GLenum target, GLint s )
    maxParam = 2;
    READ_ENUM_PARAM(0);
    READ_PARAM(v32bit,1);
    TR.skipLine();
    CHECK_USER_CALL(glMultiTexCoord1iARB)
        UCT.glMultiTexCoord1iARB(param[0].uv32bit, param[1].v32bit);
    CHECK_GL_CALL(glMultiTexCoord1iARB)
        JT.glMultiTexCoord1iARB(param[0].uv32bit, param[1].v32bit);
}

void STUB_glMultiTexCoord1iv( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glMultiTexCoord1iv( GLenum target, const GLint *v )
    maxParam = 2;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ARRAY_PARAM( 1, buffer0, TraceReader::TEXT_INT);
    TR.skipLine();
    CHECK_USER_CALL(glMultiTexCoord1iv)
        UCT.glMultiTexCoord1iv(param[0].uv32bit, (const GLint *)param[1].ptr);
    CHECK_GL_CALL(glMultiTexCoord1iv)
        JT.glMultiTexCoord1iv(param[0].uv32bit, (const GLint *)param[1].ptr);
}

void STUB_glMultiTexCoord1ivARB( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glMultiTexCoord1ivARB( GLenum target, const GLint *v )
    maxParam = 2;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ARRAY_PARAM( 1, buffer0, TraceReader::TEXT_INT);
    TR.skipLine();
    CHECK_USER_CALL(glMultiTexCoord1ivARB)
        UCT.glMultiTexCoord1ivARB(param[0].uv32bit, (const GLint *)param[1].ptr);
    CHECK_GL_CALL(glMultiTexCoord1ivARB)
        JT.glMultiTexCoord1ivARB(param[0].uv32bit, (const GLint *)param[1].ptr);
}

void STUB_glMultiTexCoord1s( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glMultiTexCoord1s( GLenum target, GLshort s )
    maxParam = 2;
    READ_ENUM_PARAM(0);
    READ_PARAM(v16bit,1);
    TR.skipLine();
    CHECK_USER_CALL(glMultiTexCoord1s)
        UCT.glMultiTexCoord1s(param[0].uv32bit, param[1].v16bit);
    CHECK_GL_CALL(glMultiTexCoord1s)
        JT.glMultiTexCoord1s(param[0].uv32bit, param[1].v16bit);
}

void STUB_glMultiTexCoord1sARB( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glMultiTexCoord1sARB( GLenum target, GLshort s )
    maxParam = 2;
    READ_ENUM_PARAM(0);
    READ_PARAM(v16bit,1);
    TR.skipLine();
    CHECK_USER_CALL(glMultiTexCoord1sARB)
        UCT.glMultiTexCoord1sARB(param[0].uv32bit, param[1].v16bit);
    CHECK_GL_CALL(glMultiTexCoord1sARB)
        JT.glMultiTexCoord1sARB(param[0].uv32bit, param[1].v16bit);
}

void STUB_glMultiTexCoord1sv( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glMultiTexCoord1sv( GLenum target, const GLshort *v )
    maxParam = 2;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ARRAY_PARAM( 1, buffer0, TraceReader::TEXT_SHORT);
    TR.skipLine();
    CHECK_USER_CALL(glMultiTexCoord1sv)
        UCT.glMultiTexCoord1sv(param[0].uv32bit, (const GLshort *)param[1].ptr);
    CHECK_GL_CALL(glMultiTexCoord1sv)
        JT.glMultiTexCoord1sv(param[0].uv32bit, (const GLshort *)param[1].ptr);
}

void STUB_glMultiTexCoord1svARB( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glMultiTexCoord1svARB( GLenum target, const GLshort *v )
    maxParam = 2;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ARRAY_PARAM( 1, buffer0, TraceReader::TEXT_SHORT);
    TR.skipLine();
    CHECK_USER_CALL(glMultiTexCoord1svARB)
        UCT.glMultiTexCoord1svARB(param[0].uv32bit, (const GLshort *)param[1].ptr);
    CHECK_GL_CALL(glMultiTexCoord1svARB)
        JT.glMultiTexCoord1svARB(param[0].uv32bit, (const GLshort *)param[1].ptr);
}

void STUB_glMultiTexCoord2d( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glMultiTexCoord2d( GLenum target, GLdouble s, GLdouble t )
    maxParam = 3;
    READ_ENUM_PARAM(0);
    READ_DOUBLE_PARAM(1);
    READ_DOUBLE_PARAM(2);
    TR.skipLine();
    CHECK_USER_CALL(glMultiTexCoord2d)
        UCT.glMultiTexCoord2d(param[0].uv32bit, param[1].fv64bit, param[2].fv64bit);
    CHECK_GL_CALL(glMultiTexCoord2d)
        JT.glMultiTexCoord2d(param[0].uv32bit, param[1].fv64bit, param[2].fv64bit);
}

void STUB_glMultiTexCoord2dARB( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glMultiTexCoord2dARB( GLenum target, GLdouble s, GLdouble t )
    maxParam = 3;
    READ_ENUM_PARAM(0);
    READ_DOUBLE_PARAM(1);
    READ_DOUBLE_PARAM(2);
    TR.skipLine();
    CHECK_USER_CALL(glMultiTexCoord2dARB)
        UCT.glMultiTexCoord2dARB(param[0].uv32bit, param[1].fv64bit, param[2].fv64bit);
    CHECK_GL_CALL(glMultiTexCoord2dARB)
        JT.glMultiTexCoord2dARB(param[0].uv32bit, param[1].fv64bit, param[2].fv64bit);
}

void STUB_glMultiTexCoord2dv( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glMultiTexCoord2dv( GLenum target, const GLdouble *v )
    maxParam = 2;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ARRAY_PARAM( 1, buffer0, TraceReader::TEXT_DOUBLE);
    TR.skipLine();
    CHECK_USER_CALL(glMultiTexCoord2dv)
        UCT.glMultiTexCoord2dv(param[0].uv32bit, (const GLdouble *)param[1].ptr);
    CHECK_GL_CALL(glMultiTexCoord2dv)
        JT.glMultiTexCoord2dv(param[0].uv32bit, (const GLdouble *)param[1].ptr);
}

void STUB_glMultiTexCoord2dvARB( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glMultiTexCoord2dvARB( GLenum target, const GLdouble *v )
    maxParam = 2;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ARRAY_PARAM( 1, buffer0, TraceReader::TEXT_DOUBLE);
    TR.skipLine();
    CHECK_USER_CALL(glMultiTexCoord2dvARB)
        UCT.glMultiTexCoord2dvARB(param[0].uv32bit, (const GLdouble *)param[1].ptr);
    CHECK_GL_CALL(glMultiTexCoord2dvARB)
        JT.glMultiTexCoord2dvARB(param[0].uv32bit, (const GLdouble *)param[1].ptr);
}

void STUB_glMultiTexCoord2f( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glMultiTexCoord2f( GLenum target, GLfloat s, GLfloat t )
    maxParam = 3;
    READ_ENUM_PARAM(0);
    READ_PARAM(fv32bit,1);
    READ_PARAM(fv32bit,2);
    TR.skipLine();
    CHECK_USER_CALL(glMultiTexCoord2f)
        UCT.glMultiTexCoord2f(param[0].uv32bit, param[1].fv32bit, param[2].fv32bit);
    CHECK_GL_CALL(glMultiTexCoord2f)
        JT.glMultiTexCoord2f(param[0].uv32bit, param[1].fv32bit, param[2].fv32bit);
}

void STUB_glMultiTexCoord2fARB( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glMultiTexCoord2fARB( GLenum target, GLfloat s, GLfloat t )
    maxParam = 3;
    READ_ENUM_PARAM(0);
    READ_PARAM(fv32bit,1);
    READ_PARAM(fv32bit,2);
    TR.skipLine();
    CHECK_USER_CALL(glMultiTexCoord2fARB)
        UCT.glMultiTexCoord2fARB(param[0].uv32bit, param[1].fv32bit, param[2].fv32bit);
    CHECK_GL_CALL(glMultiTexCoord2fARB)
        JT.glMultiTexCoord2fARB(param[0].uv32bit, param[1].fv32bit, param[2].fv32bit);
}

void STUB_glMultiTexCoord2fv( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glMultiTexCoord2fv( GLenum target, const GLfloat *v )
    maxParam = 2;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ARRAY_PARAM( 1, buffer0, TraceReader::TEXT_FLOAT);
    TR.skipLine();
    CHECK_USER_CALL(glMultiTexCoord2fv)
        UCT.glMultiTexCoord2fv(param[0].uv32bit, (const GLfloat *)param[1].ptr);
    CHECK_GL_CALL(glMultiTexCoord2fv)
        JT.glMultiTexCoord2fv(param[0].uv32bit, (const GLfloat *)param[1].ptr);
}

void STUB_glMultiTexCoord2fvARB( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glMultiTexCoord2fvARB( GLenum target, const GLfloat *v )
    maxParam = 2;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ARRAY_PARAM( 1, buffer0, TraceReader::TEXT_FLOAT);
    TR.skipLine();
    CHECK_USER_CALL(glMultiTexCoord2fvARB)
        UCT.glMultiTexCoord2fvARB(param[0].uv32bit, (const GLfloat *)param[1].ptr);
    CHECK_GL_CALL(glMultiTexCoord2fvARB)
        JT.glMultiTexCoord2fvARB(param[0].uv32bit, (const GLfloat *)param[1].ptr);
}

void STUB_glMultiTexCoord2hNV( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glMultiTexCoord2hNV( GLenum, GLhalfNV, GLhalfNV )
    // Call not playable
    TR.skipCall();
}

void STUB_glMultiTexCoord2hvNV( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glMultiTexCoord2hvNV( GLenum, const GLhalfNV * )
    // Call not playable
    TR.skipCall();
}

void STUB_glMultiTexCoord2i( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glMultiTexCoord2i( GLenum target, GLint s, GLint t )
    maxParam = 3;
    READ_ENUM_PARAM(0);
    READ_PARAM(v32bit,1);
    READ_PARAM(v32bit,2);
    TR.skipLine();
    CHECK_USER_CALL(glMultiTexCoord2i)
        UCT.glMultiTexCoord2i(param[0].uv32bit, param[1].v32bit, param[2].v32bit);
    CHECK_GL_CALL(glMultiTexCoord2i)
        JT.glMultiTexCoord2i(param[0].uv32bit, param[1].v32bit, param[2].v32bit);
}

void STUB_glMultiTexCoord2iARB( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glMultiTexCoord2iARB( GLenum target, GLint s, GLint t )
    maxParam = 3;
    READ_ENUM_PARAM(0);
    READ_PARAM(v32bit,1);
    READ_PARAM(v32bit,2);
    TR.skipLine();
    CHECK_USER_CALL(glMultiTexCoord2iARB)
        UCT.glMultiTexCoord2iARB(param[0].uv32bit, param[1].v32bit, param[2].v32bit);
    CHECK_GL_CALL(glMultiTexCoord2iARB)
        JT.glMultiTexCoord2iARB(param[0].uv32bit, param[1].v32bit, param[2].v32bit);
}

void STUB_glMultiTexCoord2iv( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glMultiTexCoord2iv( GLenum target, const GLint *v )
    maxParam = 2;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ARRAY_PARAM( 1, buffer0, TraceReader::TEXT_INT);
    TR.skipLine();
    CHECK_USER_CALL(glMultiTexCoord2iv)
        UCT.glMultiTexCoord2iv(param[0].uv32bit, (const GLint *)param[1].ptr);
    CHECK_GL_CALL(glMultiTexCoord2iv)
        JT.glMultiTexCoord2iv(param[0].uv32bit, (const GLint *)param[1].ptr);
}

void STUB_glMultiTexCoord2ivARB( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glMultiTexCoord2ivARB( GLenum target, const GLint *v )
    maxParam = 2;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ARRAY_PARAM( 1, buffer0, TraceReader::TEXT_INT);
    TR.skipLine();
    CHECK_USER_CALL(glMultiTexCoord2ivARB)
        UCT.glMultiTexCoord2ivARB(param[0].uv32bit, (const GLint *)param[1].ptr);
    CHECK_GL_CALL(glMultiTexCoord2ivARB)
        JT.glMultiTexCoord2ivARB(param[0].uv32bit, (const GLint *)param[1].ptr);
}

void STUB_glMultiTexCoord2s( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glMultiTexCoord2s( GLenum target, GLshort s, GLshort t )
    maxParam = 3;
    READ_ENUM_PARAM(0);
    READ_PARAM(v16bit,1);
    READ_PARAM(v16bit,2);
    TR.skipLine();
    CHECK_USER_CALL(glMultiTexCoord2s)
        UCT.glMultiTexCoord2s(param[0].uv32bit, param[1].v16bit, param[2].v16bit);
    CHECK_GL_CALL(glMultiTexCoord2s)
        JT.glMultiTexCoord2s(param[0].uv32bit, param[1].v16bit, param[2].v16bit);
}

void STUB_glMultiTexCoord2sARB( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glMultiTexCoord2sARB( GLenum target, GLshort s, GLshort t )
    maxParam = 3;
    READ_ENUM_PARAM(0);
    READ_PARAM(v16bit,1);
    READ_PARAM(v16bit,2);
    TR.skipLine();
    CHECK_USER_CALL(glMultiTexCoord2sARB)
        UCT.glMultiTexCoord2sARB(param[0].uv32bit, param[1].v16bit, param[2].v16bit);
    CHECK_GL_CALL(glMultiTexCoord2sARB)
        JT.glMultiTexCoord2sARB(param[0].uv32bit, param[1].v16bit, param[2].v16bit);
}

void STUB_glMultiTexCoord2sv( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glMultiTexCoord2sv( GLenum target, const GLshort *v )
    maxParam = 2;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ARRAY_PARAM( 1, buffer0, TraceReader::TEXT_SHORT);
    TR.skipLine();
    CHECK_USER_CALL(glMultiTexCoord2sv)
        UCT.glMultiTexCoord2sv(param[0].uv32bit, (const GLshort *)param[1].ptr);
    CHECK_GL_CALL(glMultiTexCoord2sv)
        JT.glMultiTexCoord2sv(param[0].uv32bit, (const GLshort *)param[1].ptr);
}

void STUB_glMultiTexCoord2svARB( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glMultiTexCoord2svARB( GLenum target, const GLshort *v )
    maxParam = 2;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ARRAY_PARAM( 1, buffer0, TraceReader::TEXT_SHORT);
    TR.skipLine();
    CHECK_USER_CALL(glMultiTexCoord2svARB)
        UCT.glMultiTexCoord2svARB(param[0].uv32bit, (const GLshort *)param[1].ptr);
    CHECK_GL_CALL(glMultiTexCoord2svARB)
        JT.glMultiTexCoord2svARB(param[0].uv32bit, (const GLshort *)param[1].ptr);
}

void STUB_glMultiTexCoord3d( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glMultiTexCoord3d( GLenum target, GLdouble s, GLdouble t, GLdouble r )
    maxParam = 4;
    READ_ENUM_PARAM(0);
    READ_DOUBLE_PARAM(1);
    READ_DOUBLE_PARAM(2);
    READ_DOUBLE_PARAM(3);
    TR.skipLine();
    CHECK_USER_CALL(glMultiTexCoord3d)
        UCT.glMultiTexCoord3d(param[0].uv32bit, param[1].fv64bit, param[2].fv64bit, param[3].fv64bit);
    CHECK_GL_CALL(glMultiTexCoord3d)
        JT.glMultiTexCoord3d(param[0].uv32bit, param[1].fv64bit, param[2].fv64bit, param[3].fv64bit);
}

void STUB_glMultiTexCoord3dARB( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glMultiTexCoord3dARB( GLenum target, GLdouble s, GLdouble t, GLdouble r )
    maxParam = 4;
    READ_ENUM_PARAM(0);
    READ_DOUBLE_PARAM(1);
    READ_DOUBLE_PARAM(2);
    READ_DOUBLE_PARAM(3);
    TR.skipLine();
    CHECK_USER_CALL(glMultiTexCoord3dARB)
        UCT.glMultiTexCoord3dARB(param[0].uv32bit, param[1].fv64bit, param[2].fv64bit, param[3].fv64bit);
    CHECK_GL_CALL(glMultiTexCoord3dARB)
        JT.glMultiTexCoord3dARB(param[0].uv32bit, param[1].fv64bit, param[2].fv64bit, param[3].fv64bit);
}

void STUB_glMultiTexCoord3dv( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glMultiTexCoord3dv( GLenum target, const GLdouble *v )
    maxParam = 2;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ARRAY_PARAM( 1, buffer0, TraceReader::TEXT_DOUBLE);
    TR.skipLine();
    CHECK_USER_CALL(glMultiTexCoord3dv)
        UCT.glMultiTexCoord3dv(param[0].uv32bit, (const GLdouble *)param[1].ptr);
    CHECK_GL_CALL(glMultiTexCoord3dv)
        JT.glMultiTexCoord3dv(param[0].uv32bit, (const GLdouble *)param[1].ptr);
}

void STUB_glMultiTexCoord3dvARB( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glMultiTexCoord3dvARB( GLenum target, const GLdouble *v )
    maxParam = 2;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ARRAY_PARAM( 1, buffer0, TraceReader::TEXT_DOUBLE);
    TR.skipLine();
    CHECK_USER_CALL(glMultiTexCoord3dvARB)
        UCT.glMultiTexCoord3dvARB(param[0].uv32bit, (const GLdouble *)param[1].ptr);
    CHECK_GL_CALL(glMultiTexCoord3dvARB)
        JT.glMultiTexCoord3dvARB(param[0].uv32bit, (const GLdouble *)param[1].ptr);
}

void STUB_glMultiTexCoord3f( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glMultiTexCoord3f( GLenum target, GLfloat s, GLfloat t, GLfloat r )
    maxParam = 4;
    READ_ENUM_PARAM(0);
    READ_PARAM(fv32bit,1);
    READ_PARAM(fv32bit,2);
    READ_PARAM(fv32bit,3);
    TR.skipLine();
    CHECK_USER_CALL(glMultiTexCoord3f)
        UCT.glMultiTexCoord3f(param[0].uv32bit, param[1].fv32bit, param[2].fv32bit, param[3].fv32bit);
    CHECK_GL_CALL(glMultiTexCoord3f)
        JT.glMultiTexCoord3f(param[0].uv32bit, param[1].fv32bit, param[2].fv32bit, param[3].fv32bit);
}

void STUB_glMultiTexCoord3fARB( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glMultiTexCoord3fARB( GLenum target, GLfloat s, GLfloat t, GLfloat r )
    maxParam = 4;
    READ_ENUM_PARAM(0);
    READ_PARAM(fv32bit,1);
    READ_PARAM(fv32bit,2);
    READ_PARAM(fv32bit,3);
    TR.skipLine();
    CHECK_USER_CALL(glMultiTexCoord3fARB)
        UCT.glMultiTexCoord3fARB(param[0].uv32bit, param[1].fv32bit, param[2].fv32bit, param[3].fv32bit);
    CHECK_GL_CALL(glMultiTexCoord3fARB)
        JT.glMultiTexCoord3fARB(param[0].uv32bit, param[1].fv32bit, param[2].fv32bit, param[3].fv32bit);
}

void STUB_glMultiTexCoord3fv( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glMultiTexCoord3fv( GLenum target, const GLfloat *v )
    maxParam = 2;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ARRAY_PARAM( 1, buffer0, TraceReader::TEXT_FLOAT);
    TR.skipLine();
    CHECK_USER_CALL(glMultiTexCoord3fv)
        UCT.glMultiTexCoord3fv(param[0].uv32bit, (const GLfloat *)param[1].ptr);
    CHECK_GL_CALL(glMultiTexCoord3fv)
        JT.glMultiTexCoord3fv(param[0].uv32bit, (const GLfloat *)param[1].ptr);
}

void STUB_glMultiTexCoord3fvARB( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glMultiTexCoord3fvARB( GLenum target, const GLfloat *v )
    maxParam = 2;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ARRAY_PARAM( 1, buffer0, TraceReader::TEXT_FLOAT);
    TR.skipLine();
    CHECK_USER_CALL(glMultiTexCoord3fvARB)
        UCT.glMultiTexCoord3fvARB(param[0].uv32bit, (const GLfloat *)param[1].ptr);
    CHECK_GL_CALL(glMultiTexCoord3fvARB)
        JT.glMultiTexCoord3fvARB(param[0].uv32bit, (const GLfloat *)param[1].ptr);
}

void STUB_glMultiTexCoord3hNV( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glMultiTexCoord3hNV( GLenum, GLhalfNV, GLhalfNV, GLhalfNV )
    // Call not playable
    TR.skipCall();
}

void STUB_glMultiTexCoord3hvNV( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glMultiTexCoord3hvNV( GLenum, const GLhalfNV * )
    // Call not playable
    TR.skipCall();
}

void STUB_glMultiTexCoord3i( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glMultiTexCoord3i( GLenum target, GLint s, GLint t, GLint r )
    maxParam = 4;
    READ_ENUM_PARAM(0);
    READ_PARAM(v32bit,1);
    READ_PARAM(v32bit,2);
    READ_PARAM(v32bit,3);
    TR.skipLine();
    CHECK_USER_CALL(glMultiTexCoord3i)
        UCT.glMultiTexCoord3i(param[0].uv32bit, param[1].v32bit, param[2].v32bit, param[3].v32bit);
    CHECK_GL_CALL(glMultiTexCoord3i)
        JT.glMultiTexCoord3i(param[0].uv32bit, param[1].v32bit, param[2].v32bit, param[3].v32bit);
}

void STUB_glMultiTexCoord3iARB( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glMultiTexCoord3iARB( GLenum target, GLint s, GLint t, GLint r )
    maxParam = 4;
    READ_ENUM_PARAM(0);
    READ_PARAM(v32bit,1);
    READ_PARAM(v32bit,2);
    READ_PARAM(v32bit,3);
    TR.skipLine();
    CHECK_USER_CALL(glMultiTexCoord3iARB)
        UCT.glMultiTexCoord3iARB(param[0].uv32bit, param[1].v32bit, param[2].v32bit, param[3].v32bit);
    CHECK_GL_CALL(glMultiTexCoord3iARB)
        JT.glMultiTexCoord3iARB(param[0].uv32bit, param[1].v32bit, param[2].v32bit, param[3].v32bit);
}

void STUB_glMultiTexCoord3iv( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glMultiTexCoord3iv( GLenum target, const GLint *v )
    maxParam = 2;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ARRAY_PARAM( 1, buffer0, TraceReader::TEXT_INT);
    TR.skipLine();
    CHECK_USER_CALL(glMultiTexCoord3iv)
        UCT.glMultiTexCoord3iv(param[0].uv32bit, (const GLint *)param[1].ptr);
    CHECK_GL_CALL(glMultiTexCoord3iv)
        JT.glMultiTexCoord3iv(param[0].uv32bit, (const GLint *)param[1].ptr);
}

void STUB_glMultiTexCoord3ivARB( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glMultiTexCoord3ivARB( GLenum target, const GLint *v )
    maxParam = 2;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ARRAY_PARAM( 1, buffer0, TraceReader::TEXT_INT);
    TR.skipLine();
    CHECK_USER_CALL(glMultiTexCoord3ivARB)
        UCT.glMultiTexCoord3ivARB(param[0].uv32bit, (const GLint *)param[1].ptr);
    CHECK_GL_CALL(glMultiTexCoord3ivARB)
        JT.glMultiTexCoord3ivARB(param[0].uv32bit, (const GLint *)param[1].ptr);
}

void STUB_glMultiTexCoord3s( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glMultiTexCoord3s( GLenum target, GLshort s, GLshort t, GLshort r )
    maxParam = 4;
    READ_ENUM_PARAM(0);
    READ_PARAM(v16bit,1);
    READ_PARAM(v16bit,2);
    READ_PARAM(v16bit,3);
    TR.skipLine();
    CHECK_USER_CALL(glMultiTexCoord3s)
        UCT.glMultiTexCoord3s(param[0].uv32bit, param[1].v16bit, param[2].v16bit, param[3].v16bit);
    CHECK_GL_CALL(glMultiTexCoord3s)
        JT.glMultiTexCoord3s(param[0].uv32bit, param[1].v16bit, param[2].v16bit, param[3].v16bit);
}

void STUB_glMultiTexCoord3sARB( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glMultiTexCoord3sARB( GLenum target, GLshort s, GLshort t, GLshort r )
    maxParam = 4;
    READ_ENUM_PARAM(0);
    READ_PARAM(v16bit,1);
    READ_PARAM(v16bit,2);
    READ_PARAM(v16bit,3);
    TR.skipLine();
    CHECK_USER_CALL(glMultiTexCoord3sARB)
        UCT.glMultiTexCoord3sARB(param[0].uv32bit, param[1].v16bit, param[2].v16bit, param[3].v16bit);
    CHECK_GL_CALL(glMultiTexCoord3sARB)
        JT.glMultiTexCoord3sARB(param[0].uv32bit, param[1].v16bit, param[2].v16bit, param[3].v16bit);
}

void STUB_glMultiTexCoord3sv( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glMultiTexCoord3sv( GLenum target, const GLshort *v )
    maxParam = 2;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ARRAY_PARAM( 1, buffer0, TraceReader::TEXT_SHORT);
    TR.skipLine();
    CHECK_USER_CALL(glMultiTexCoord3sv)
        UCT.glMultiTexCoord3sv(param[0].uv32bit, (const GLshort *)param[1].ptr);
    CHECK_GL_CALL(glMultiTexCoord3sv)
        JT.glMultiTexCoord3sv(param[0].uv32bit, (const GLshort *)param[1].ptr);
}

void STUB_glMultiTexCoord3svARB( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glMultiTexCoord3svARB( GLenum target, const GLshort *v )
    maxParam = 2;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ARRAY_PARAM( 1, buffer0, TraceReader::TEXT_SHORT);
    TR.skipLine();
    CHECK_USER_CALL(glMultiTexCoord3svARB)
        UCT.glMultiTexCoord3svARB(param[0].uv32bit, (const GLshort *)param[1].ptr);
    CHECK_GL_CALL(glMultiTexCoord3svARB)
        JT.glMultiTexCoord3svARB(param[0].uv32bit, (const GLshort *)param[1].ptr);
}

void STUB_glMultiTexCoord4d( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glMultiTexCoord4d( GLenum target, GLdouble s, GLdouble t, GLdouble r, GLdouble q )
    maxParam = 5;
    READ_ENUM_PARAM(0);
    READ_DOUBLE_PARAM(1);
    READ_DOUBLE_PARAM(2);
    READ_DOUBLE_PARAM(3);
    READ_DOUBLE_PARAM(4);
    TR.skipLine();
    CHECK_USER_CALL(glMultiTexCoord4d)
        UCT.glMultiTexCoord4d(param[0].uv32bit, param[1].fv64bit, param[2].fv64bit, param[3].fv64bit, param[4].fv64bit);
    CHECK_GL_CALL(glMultiTexCoord4d)
        JT.glMultiTexCoord4d(param[0].uv32bit, param[1].fv64bit, param[2].fv64bit, param[3].fv64bit, param[4].fv64bit);
}

void STUB_glMultiTexCoord4dARB( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glMultiTexCoord4dARB( GLenum target, GLdouble s, GLdouble t, GLdouble r, GLdouble q )
    maxParam = 5;
    READ_ENUM_PARAM(0);
    READ_DOUBLE_PARAM(1);
    READ_DOUBLE_PARAM(2);
    READ_DOUBLE_PARAM(3);
    READ_DOUBLE_PARAM(4);
    TR.skipLine();
    CHECK_USER_CALL(glMultiTexCoord4dARB)
        UCT.glMultiTexCoord4dARB(param[0].uv32bit, param[1].fv64bit, param[2].fv64bit, param[3].fv64bit, param[4].fv64bit);
    CHECK_GL_CALL(glMultiTexCoord4dARB)
        JT.glMultiTexCoord4dARB(param[0].uv32bit, param[1].fv64bit, param[2].fv64bit, param[3].fv64bit, param[4].fv64bit);
}

void STUB_glMultiTexCoord4dv( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glMultiTexCoord4dv( GLenum target, const GLdouble *v )
    maxParam = 2;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ARRAY_PARAM( 1, buffer0, TraceReader::TEXT_DOUBLE);
    TR.skipLine();
    CHECK_USER_CALL(glMultiTexCoord4dv)
        UCT.glMultiTexCoord4dv(param[0].uv32bit, (const GLdouble *)param[1].ptr);
    CHECK_GL_CALL(glMultiTexCoord4dv)
        JT.glMultiTexCoord4dv(param[0].uv32bit, (const GLdouble *)param[1].ptr);
}

void STUB_glMultiTexCoord4dvARB( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glMultiTexCoord4dvARB( GLenum target, const GLdouble *v )
    maxParam = 2;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ARRAY_PARAM( 1, buffer0, TraceReader::TEXT_DOUBLE);
    TR.skipLine();
    CHECK_USER_CALL(glMultiTexCoord4dvARB)
        UCT.glMultiTexCoord4dvARB(param[0].uv32bit, (const GLdouble *)param[1].ptr);
    CHECK_GL_CALL(glMultiTexCoord4dvARB)
        JT.glMultiTexCoord4dvARB(param[0].uv32bit, (const GLdouble *)param[1].ptr);
}

void STUB_glMultiTexCoord4f( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glMultiTexCoord4f( GLenum target, GLfloat s, GLfloat t, GLfloat r, GLfloat q )
    maxParam = 5;
    READ_ENUM_PARAM(0);
    READ_PARAM(fv32bit,1);
    READ_PARAM(fv32bit,2);
    READ_PARAM(fv32bit,3);
    READ_PARAM(fv32bit,4);
    TR.skipLine();
    CHECK_USER_CALL(glMultiTexCoord4f)
        UCT.glMultiTexCoord4f(param[0].uv32bit, param[1].fv32bit, param[2].fv32bit, param[3].fv32bit, param[4].fv32bit);
    CHECK_GL_CALL(glMultiTexCoord4f)
        JT.glMultiTexCoord4f(param[0].uv32bit, param[1].fv32bit, param[2].fv32bit, param[3].fv32bit, param[4].fv32bit);
}

void STUB_glMultiTexCoord4fARB( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glMultiTexCoord4fARB( GLenum target, GLfloat s, GLfloat t, GLfloat r, GLfloat q )
    maxParam = 5;
    READ_ENUM_PARAM(0);
    READ_PARAM(fv32bit,1);
    READ_PARAM(fv32bit,2);
    READ_PARAM(fv32bit,3);
    READ_PARAM(fv32bit,4);
    TR.skipLine();
    CHECK_USER_CALL(glMultiTexCoord4fARB)
        UCT.glMultiTexCoord4fARB(param[0].uv32bit, param[1].fv32bit, param[2].fv32bit, param[3].fv32bit, param[4].fv32bit);
    CHECK_GL_CALL(glMultiTexCoord4fARB)
        JT.glMultiTexCoord4fARB(param[0].uv32bit, param[1].fv32bit, param[2].fv32bit, param[3].fv32bit, param[4].fv32bit);
}

void STUB_glMultiTexCoord4fv( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glMultiTexCoord4fv( GLenum target, const GLfloat *v )
    maxParam = 2;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ARRAY_PARAM( 1, buffer0, TraceReader::TEXT_FLOAT);
    TR.skipLine();
    CHECK_USER_CALL(glMultiTexCoord4fv)
        UCT.glMultiTexCoord4fv(param[0].uv32bit, (const GLfloat *)param[1].ptr);
    CHECK_GL_CALL(glMultiTexCoord4fv)
        JT.glMultiTexCoord4fv(param[0].uv32bit, (const GLfloat *)param[1].ptr);
}

void STUB_glMultiTexCoord4fvARB( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glMultiTexCoord4fvARB( GLenum target, const GLfloat *v )
    maxParam = 2;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ARRAY_PARAM( 1, buffer0, TraceReader::TEXT_FLOAT);
    TR.skipLine();
    CHECK_USER_CALL(glMultiTexCoord4fvARB)
        UCT.glMultiTexCoord4fvARB(param[0].uv32bit, (const GLfloat *)param[1].ptr);
    CHECK_GL_CALL(glMultiTexCoord4fvARB)
        JT.glMultiTexCoord4fvARB(param[0].uv32bit, (const GLfloat *)param[1].ptr);
}

void STUB_glMultiTexCoord4hNV( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glMultiTexCoord4hNV( GLenum, GLhalfNV, GLhalfNV, GLhalfNV, GLhalfNV )
    // Call not playable
    TR.skipCall();
}

void STUB_glMultiTexCoord4hvNV( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glMultiTexCoord4hvNV( GLenum, const GLhalfNV * )
    // Call not playable
    TR.skipCall();
}

void STUB_glMultiTexCoord4i( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glMultiTexCoord4i( GLenum target, GLint s, GLint t, GLint r, GLint q )
    maxParam = 5;
    READ_ENUM_PARAM(0);
    READ_PARAM(v32bit,1);
    READ_PARAM(v32bit,2);
    READ_PARAM(v32bit,3);
    READ_PARAM(v32bit,4);
    TR.skipLine();
    CHECK_USER_CALL(glMultiTexCoord4i)
        UCT.glMultiTexCoord4i(param[0].uv32bit, param[1].v32bit, param[2].v32bit, param[3].v32bit, param[4].v32bit);
    CHECK_GL_CALL(glMultiTexCoord4i)
        JT.glMultiTexCoord4i(param[0].uv32bit, param[1].v32bit, param[2].v32bit, param[3].v32bit, param[4].v32bit);
}

void STUB_glMultiTexCoord4iARB( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glMultiTexCoord4iARB( GLenum target, GLint s, GLint t, GLint r, GLint q )
    maxParam = 5;
    READ_ENUM_PARAM(0);
    READ_PARAM(v32bit,1);
    READ_PARAM(v32bit,2);
    READ_PARAM(v32bit,3);
    READ_PARAM(v32bit,4);
    TR.skipLine();
    CHECK_USER_CALL(glMultiTexCoord4iARB)
        UCT.glMultiTexCoord4iARB(param[0].uv32bit, param[1].v32bit, param[2].v32bit, param[3].v32bit, param[4].v32bit);
    CHECK_GL_CALL(glMultiTexCoord4iARB)
        JT.glMultiTexCoord4iARB(param[0].uv32bit, param[1].v32bit, param[2].v32bit, param[3].v32bit, param[4].v32bit);
}

void STUB_glMultiTexCoord4iv( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glMultiTexCoord4iv( GLenum target, const GLint *v )
    maxParam = 2;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ARRAY_PARAM( 1, buffer0, TraceReader::TEXT_INT);
    TR.skipLine();
    CHECK_USER_CALL(glMultiTexCoord4iv)
        UCT.glMultiTexCoord4iv(param[0].uv32bit, (const GLint *)param[1].ptr);
    CHECK_GL_CALL(glMultiTexCoord4iv)
        JT.glMultiTexCoord4iv(param[0].uv32bit, (const GLint *)param[1].ptr);
}

void STUB_glMultiTexCoord4ivARB( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glMultiTexCoord4ivARB( GLenum target, const GLint *v )
    maxParam = 2;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ARRAY_PARAM( 1, buffer0, TraceReader::TEXT_INT);
    TR.skipLine();
    CHECK_USER_CALL(glMultiTexCoord4ivARB)
        UCT.glMultiTexCoord4ivARB(param[0].uv32bit, (const GLint *)param[1].ptr);
    CHECK_GL_CALL(glMultiTexCoord4ivARB)
        JT.glMultiTexCoord4ivARB(param[0].uv32bit, (const GLint *)param[1].ptr);
}

void STUB_glMultiTexCoord4s( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glMultiTexCoord4s( GLenum target, GLshort s, GLshort t, GLshort r, GLshort q )
    maxParam = 5;
    READ_ENUM_PARAM(0);
    READ_PARAM(v16bit,1);
    READ_PARAM(v16bit,2);
    READ_PARAM(v16bit,3);
    READ_PARAM(v16bit,4);
    TR.skipLine();
    CHECK_USER_CALL(glMultiTexCoord4s)
        UCT.glMultiTexCoord4s(param[0].uv32bit, param[1].v16bit, param[2].v16bit, param[3].v16bit, param[4].v16bit);
    CHECK_GL_CALL(glMultiTexCoord4s)
        JT.glMultiTexCoord4s(param[0].uv32bit, param[1].v16bit, param[2].v16bit, param[3].v16bit, param[4].v16bit);
}

void STUB_glMultiTexCoord4sARB( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glMultiTexCoord4sARB( GLenum target, GLshort s, GLshort t, GLshort r, GLshort q )
    maxParam = 5;
    READ_ENUM_PARAM(0);
    READ_PARAM(v16bit,1);
    READ_PARAM(v16bit,2);
    READ_PARAM(v16bit,3);
    READ_PARAM(v16bit,4);
    TR.skipLine();
    CHECK_USER_CALL(glMultiTexCoord4sARB)
        UCT.glMultiTexCoord4sARB(param[0].uv32bit, param[1].v16bit, param[2].v16bit, param[3].v16bit, param[4].v16bit);
    CHECK_GL_CALL(glMultiTexCoord4sARB)
        JT.glMultiTexCoord4sARB(param[0].uv32bit, param[1].v16bit, param[2].v16bit, param[3].v16bit, param[4].v16bit);
}

void STUB_glMultiTexCoord4sv( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glMultiTexCoord4sv( GLenum target, const GLshort *v )
    maxParam = 2;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ARRAY_PARAM( 1, buffer0, TraceReader::TEXT_SHORT);
    TR.skipLine();
    CHECK_USER_CALL(glMultiTexCoord4sv)
        UCT.glMultiTexCoord4sv(param[0].uv32bit, (const GLshort *)param[1].ptr);
    CHECK_GL_CALL(glMultiTexCoord4sv)
        JT.glMultiTexCoord4sv(param[0].uv32bit, (const GLshort *)param[1].ptr);
}

void STUB_glMultiTexCoord4svARB( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glMultiTexCoord4svARB( GLenum target, const GLshort *v )
    maxParam = 2;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ARRAY_PARAM( 1, buffer0, TraceReader::TEXT_SHORT);
    TR.skipLine();
    CHECK_USER_CALL(glMultiTexCoord4svARB)
        UCT.glMultiTexCoord4svARB(param[0].uv32bit, (const GLshort *)param[1].ptr);
    CHECK_GL_CALL(glMultiTexCoord4svARB)
        JT.glMultiTexCoord4svARB(param[0].uv32bit, (const GLshort *)param[1].ptr);
}

void STUB_glMultiTexCoordPointerEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glMultiTexCoordPointerEXT( GLenum, GLint, GLenum, GLsizei, const GLvoid * )
    maxParam = 5;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_PARAM(v32bit,1);
    READ_ENUM_PARAM(2);
    READ_PARAM(v32bit,3);
    READ_ARRAY_PARAM( 4, buffer0, TraceReader::TEXT_IGNORE);
    TR.skipLine();
    CHECK_USER_CALL(glMultiTexCoordPointerEXT)
        UCT.glMultiTexCoordPointerEXT(param[0].uv32bit, param[1].v32bit, param[2].uv32bit, param[3].v32bit, (const GLvoid *)param[4].ptr);
    CHECK_GL_CALL(glMultiTexCoordPointerEXT)
        JT.glMultiTexCoordPointerEXT(param[0].uv32bit, param[1].v32bit, param[2].uv32bit, param[3].v32bit, (const GLvoid *)param[4].ptr);
}

void STUB_glMultiTexEnvfEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glMultiTexEnvfEXT( GLenum, GLenum, GLenum, GLfloat )
    maxParam = 4;
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_ENUM_PARAM(2);
    READ_PARAM(fv32bit,3);
    TR.skipLine();
    CHECK_USER_CALL(glMultiTexEnvfEXT)
        UCT.glMultiTexEnvfEXT(param[0].uv32bit, param[1].uv32bit, param[2].uv32bit, param[3].fv32bit);
    CHECK_GL_CALL(glMultiTexEnvfEXT)
        JT.glMultiTexEnvfEXT(param[0].uv32bit, param[1].uv32bit, param[2].uv32bit, param[3].fv32bit);
}

void STUB_glMultiTexEnvfvEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glMultiTexEnvfvEXT( GLenum, GLenum, GLenum, const GLfloat * )
    maxParam = 4;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_ENUM_PARAM(2);
    READ_ARRAY_PARAM( 3, buffer0, TraceReader::TEXT_FLOAT);
    TR.skipLine();
    CHECK_USER_CALL(glMultiTexEnvfvEXT)
        UCT.glMultiTexEnvfvEXT(param[0].uv32bit, param[1].uv32bit, param[2].uv32bit, (const GLfloat *)param[3].ptr);
    CHECK_GL_CALL(glMultiTexEnvfvEXT)
        JT.glMultiTexEnvfvEXT(param[0].uv32bit, param[1].uv32bit, param[2].uv32bit, (const GLfloat *)param[3].ptr);
}

void STUB_glMultiTexEnviEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glMultiTexEnviEXT( GLenum, GLenum, GLenum, GLint )
    maxParam = 4;
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_ENUM_PARAM(2);
    READ_PARAM(v32bit,3);
    TR.skipLine();
    CHECK_USER_CALL(glMultiTexEnviEXT)
        UCT.glMultiTexEnviEXT(param[0].uv32bit, param[1].uv32bit, param[2].uv32bit, param[3].v32bit);
    CHECK_GL_CALL(glMultiTexEnviEXT)
        JT.glMultiTexEnviEXT(param[0].uv32bit, param[1].uv32bit, param[2].uv32bit, param[3].v32bit);
}

void STUB_glMultiTexEnvivEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glMultiTexEnvivEXT( GLenum, GLenum, GLenum, const GLint * )
    maxParam = 4;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_ENUM_PARAM(2);
    READ_ARRAY_PARAM( 3, buffer0, TraceReader::TEXT_INT);
    TR.skipLine();
    CHECK_USER_CALL(glMultiTexEnvivEXT)
        UCT.glMultiTexEnvivEXT(param[0].uv32bit, param[1].uv32bit, param[2].uv32bit, (const GLint *)param[3].ptr);
    CHECK_GL_CALL(glMultiTexEnvivEXT)
        JT.glMultiTexEnvivEXT(param[0].uv32bit, param[1].uv32bit, param[2].uv32bit, (const GLint *)param[3].ptr);
}

void STUB_glMultiTexGendEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glMultiTexGendEXT( GLenum, GLenum, GLenum, GLdouble )
    maxParam = 4;
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_ENUM_PARAM(2);
    READ_DOUBLE_PARAM(3);
    TR.skipLine();
    CHECK_USER_CALL(glMultiTexGendEXT)
        UCT.glMultiTexGendEXT(param[0].uv32bit, param[1].uv32bit, param[2].uv32bit, param[3].fv64bit);
    CHECK_GL_CALL(glMultiTexGendEXT)
        JT.glMultiTexGendEXT(param[0].uv32bit, param[1].uv32bit, param[2].uv32bit, param[3].fv64bit);
}

void STUB_glMultiTexGendvEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glMultiTexGendvEXT( GLenum, GLenum, GLenum, const GLdouble * )
    maxParam = 4;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_ENUM_PARAM(2);
    READ_ARRAY_PARAM( 3, buffer0, TraceReader::TEXT_DOUBLE);
    TR.skipLine();
    CHECK_USER_CALL(glMultiTexGendvEXT)
        UCT.glMultiTexGendvEXT(param[0].uv32bit, param[1].uv32bit, param[2].uv32bit, (const GLdouble *)param[3].ptr);
    CHECK_GL_CALL(glMultiTexGendvEXT)
        JT.glMultiTexGendvEXT(param[0].uv32bit, param[1].uv32bit, param[2].uv32bit, (const GLdouble *)param[3].ptr);
}

void STUB_glMultiTexGenfEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glMultiTexGenfEXT( GLenum, GLenum, GLenum, GLfloat )
    maxParam = 4;
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_ENUM_PARAM(2);
    READ_PARAM(fv32bit,3);
    TR.skipLine();
    CHECK_USER_CALL(glMultiTexGenfEXT)
        UCT.glMultiTexGenfEXT(param[0].uv32bit, param[1].uv32bit, param[2].uv32bit, param[3].fv32bit);
    CHECK_GL_CALL(glMultiTexGenfEXT)
        JT.glMultiTexGenfEXT(param[0].uv32bit, param[1].uv32bit, param[2].uv32bit, param[3].fv32bit);
}

void STUB_glMultiTexGenfvEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glMultiTexGenfvEXT( GLenum, GLenum, GLenum, const GLfloat * )
    maxParam = 4;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_ENUM_PARAM(2);
    READ_ARRAY_PARAM( 3, buffer0, TraceReader::TEXT_FLOAT);
    TR.skipLine();
    CHECK_USER_CALL(glMultiTexGenfvEXT)
        UCT.glMultiTexGenfvEXT(param[0].uv32bit, param[1].uv32bit, param[2].uv32bit, (const GLfloat *)param[3].ptr);
    CHECK_GL_CALL(glMultiTexGenfvEXT)
        JT.glMultiTexGenfvEXT(param[0].uv32bit, param[1].uv32bit, param[2].uv32bit, (const GLfloat *)param[3].ptr);
}

void STUB_glMultiTexGeniEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glMultiTexGeniEXT( GLenum, GLenum, GLenum, GLint )
    maxParam = 4;
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_ENUM_PARAM(2);
    READ_PARAM(v32bit,3);
    TR.skipLine();
    CHECK_USER_CALL(glMultiTexGeniEXT)
        UCT.glMultiTexGeniEXT(param[0].uv32bit, param[1].uv32bit, param[2].uv32bit, param[3].v32bit);
    CHECK_GL_CALL(glMultiTexGeniEXT)
        JT.glMultiTexGeniEXT(param[0].uv32bit, param[1].uv32bit, param[2].uv32bit, param[3].v32bit);
}

void STUB_glMultiTexGenivEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glMultiTexGenivEXT( GLenum, GLenum, GLenum, const GLint * )
    maxParam = 4;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_ENUM_PARAM(2);
    READ_ARRAY_PARAM( 3, buffer0, TraceReader::TEXT_INT);
    TR.skipLine();
    CHECK_USER_CALL(glMultiTexGenivEXT)
        UCT.glMultiTexGenivEXT(param[0].uv32bit, param[1].uv32bit, param[2].uv32bit, (const GLint *)param[3].ptr);
    CHECK_GL_CALL(glMultiTexGenivEXT)
        JT.glMultiTexGenivEXT(param[0].uv32bit, param[1].uv32bit, param[2].uv32bit, (const GLint *)param[3].ptr);
}

void STUB_glMultiTexImage1DEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glMultiTexImage1DEXT( GLenum, GLenum, GLint, GLenum, GLsizei, GLint, GLenum, GLenum, const GLvoid * )
    maxParam = 9;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_PARAM(v32bit,2);
    READ_ENUM_PARAM(3);
    READ_PARAM(v32bit,4);
    READ_PARAM(v32bit,5);
    READ_ENUM_PARAM(6);
    READ_ENUM_PARAM(7);
    READ_ARRAY_PARAM( 8, buffer0, TraceReader::TEXT_IGNORE);
    TR.skipLine();
    CHECK_USER_CALL(glMultiTexImage1DEXT)
        UCT.glMultiTexImage1DEXT(param[0].uv32bit, param[1].uv32bit, param[2].v32bit, param[3].uv32bit, param[4].v32bit, param[5].v32bit, param[6].uv32bit, param[7].uv32bit, (const GLvoid *)param[8].ptr);
    CHECK_GL_CALL(glMultiTexImage1DEXT)
        JT.glMultiTexImage1DEXT(param[0].uv32bit, param[1].uv32bit, param[2].v32bit, param[3].uv32bit, param[4].v32bit, param[5].v32bit, param[6].uv32bit, param[7].uv32bit, (const GLvoid *)param[8].ptr);
}

void STUB_glMultiTexImage2DEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glMultiTexImage2DEXT( GLenum, GLenum, GLint, GLenum, GLsizei, GLsizei, GLint, GLenum, GLenum, const GLvoid * )
    maxParam = 10;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_PARAM(v32bit,2);
    READ_ENUM_PARAM(3);
    READ_PARAM(v32bit,4);
    READ_PARAM(v32bit,5);
    READ_PARAM(v32bit,6);
    READ_ENUM_PARAM(7);
    READ_ENUM_PARAM(8);
    READ_ARRAY_PARAM( 9, buffer0, TraceReader::TEXT_IGNORE);
    TR.skipLine();
    CHECK_USER_CALL(glMultiTexImage2DEXT)
        UCT.glMultiTexImage2DEXT(param[0].uv32bit, param[1].uv32bit, param[2].v32bit, param[3].uv32bit, param[4].v32bit, param[5].v32bit, param[6].v32bit, param[7].uv32bit, param[8].uv32bit, (const GLvoid *)param[9].ptr);
    CHECK_GL_CALL(glMultiTexImage2DEXT)
        JT.glMultiTexImage2DEXT(param[0].uv32bit, param[1].uv32bit, param[2].v32bit, param[3].uv32bit, param[4].v32bit, param[5].v32bit, param[6].v32bit, param[7].uv32bit, param[8].uv32bit, (const GLvoid *)param[9].ptr);
}

void STUB_glMultiTexImage3DEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glMultiTexImage3DEXT( GLenum, GLenum, GLint, GLenum, GLsizei, GLsizei, GLsizei, GLint, GLenum, GLenum, const GLvoid * )
    maxParam = 11;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_PARAM(v32bit,2);
    READ_ENUM_PARAM(3);
    READ_PARAM(v32bit,4);
    READ_PARAM(v32bit,5);
    READ_PARAM(v32bit,6);
    READ_PARAM(v32bit,7);
    READ_ENUM_PARAM(8);
    READ_ENUM_PARAM(9);
    READ_ARRAY_PARAM( 10, buffer0, TraceReader::TEXT_IGNORE);
    TR.skipLine();
    CHECK_USER_CALL(glMultiTexImage3DEXT)
        UCT.glMultiTexImage3DEXT(param[0].uv32bit, param[1].uv32bit, param[2].v32bit, param[3].uv32bit, param[4].v32bit, param[5].v32bit, param[6].v32bit, param[7].v32bit, param[8].uv32bit, param[9].uv32bit, (const GLvoid *)param[10].ptr);
    CHECK_GL_CALL(glMultiTexImage3DEXT)
        JT.glMultiTexImage3DEXT(param[0].uv32bit, param[1].uv32bit, param[2].v32bit, param[3].uv32bit, param[4].v32bit, param[5].v32bit, param[6].v32bit, param[7].v32bit, param[8].uv32bit, param[9].uv32bit, (const GLvoid *)param[10].ptr);
}

void STUB_glMultiTexParameterIivEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glMultiTexParameterIivEXT( GLenum, GLenum, GLenum, const GLint * )
    maxParam = 4;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_ENUM_PARAM(2);
    READ_ARRAY_PARAM( 3, buffer0, TraceReader::TEXT_INT);
    TR.skipLine();
    CHECK_USER_CALL(glMultiTexParameterIivEXT)
        UCT.glMultiTexParameterIivEXT(param[0].uv32bit, param[1].uv32bit, param[2].uv32bit, (const GLint *)param[3].ptr);
    CHECK_GL_CALL(glMultiTexParameterIivEXT)
        JT.glMultiTexParameterIivEXT(param[0].uv32bit, param[1].uv32bit, param[2].uv32bit, (const GLint *)param[3].ptr);
}

void STUB_glMultiTexParameterIuivEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glMultiTexParameterIuivEXT( GLenum, GLenum, GLenum, const GLuint * )
    maxParam = 4;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_ENUM_PARAM(2);
    READ_ARRAY_PARAM( 3, buffer0, TraceReader::TEXT_INT);
    TR.skipLine();
    CHECK_USER_CALL(glMultiTexParameterIuivEXT)
        UCT.glMultiTexParameterIuivEXT(param[0].uv32bit, param[1].uv32bit, param[2].uv32bit, (const GLuint *)param[3].ptr);
    CHECK_GL_CALL(glMultiTexParameterIuivEXT)
        JT.glMultiTexParameterIuivEXT(param[0].uv32bit, param[1].uv32bit, param[2].uv32bit, (const GLuint *)param[3].ptr);
}

void STUB_glMultiTexParameterfEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glMultiTexParameterfEXT( GLenum, GLenum, GLenum, GLfloat )
    maxParam = 4;
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_ENUM_PARAM(2);
    READ_PARAM(fv32bit,3);
    TR.skipLine();
    CHECK_USER_CALL(glMultiTexParameterfEXT)
        UCT.glMultiTexParameterfEXT(param[0].uv32bit, param[1].uv32bit, param[2].uv32bit, param[3].fv32bit);
    CHECK_GL_CALL(glMultiTexParameterfEXT)
        JT.glMultiTexParameterfEXT(param[0].uv32bit, param[1].uv32bit, param[2].uv32bit, param[3].fv32bit);
}

void STUB_glMultiTexParameterfvEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glMultiTexParameterfvEXT( GLenum, GLenum, GLenum, const GLfloat * )
    maxParam = 4;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_ENUM_PARAM(2);
    READ_ARRAY_PARAM( 3, buffer0, TraceReader::TEXT_FLOAT);
    TR.skipLine();
    CHECK_USER_CALL(glMultiTexParameterfvEXT)
        UCT.glMultiTexParameterfvEXT(param[0].uv32bit, param[1].uv32bit, param[2].uv32bit, (const GLfloat *)param[3].ptr);
    CHECK_GL_CALL(glMultiTexParameterfvEXT)
        JT.glMultiTexParameterfvEXT(param[0].uv32bit, param[1].uv32bit, param[2].uv32bit, (const GLfloat *)param[3].ptr);
}

void STUB_glMultiTexParameteriEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glMultiTexParameteriEXT( GLenum, GLenum, GLenum, GLint )
    maxParam = 4;
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_ENUM_PARAM(2);
    READ_PARAM(v32bit,3);
    TR.skipLine();
    CHECK_USER_CALL(glMultiTexParameteriEXT)
        UCT.glMultiTexParameteriEXT(param[0].uv32bit, param[1].uv32bit, param[2].uv32bit, param[3].v32bit);
    CHECK_GL_CALL(glMultiTexParameteriEXT)
        JT.glMultiTexParameteriEXT(param[0].uv32bit, param[1].uv32bit, param[2].uv32bit, param[3].v32bit);
}

void STUB_glMultiTexParameterivEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glMultiTexParameterivEXT( GLenum, GLenum, GLenum, const GLint * )
    maxParam = 4;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_ENUM_PARAM(2);
    READ_ARRAY_PARAM( 3, buffer0, TraceReader::TEXT_INT);
    TR.skipLine();
    CHECK_USER_CALL(glMultiTexParameterivEXT)
        UCT.glMultiTexParameterivEXT(param[0].uv32bit, param[1].uv32bit, param[2].uv32bit, (const GLint *)param[3].ptr);
    CHECK_GL_CALL(glMultiTexParameterivEXT)
        JT.glMultiTexParameterivEXT(param[0].uv32bit, param[1].uv32bit, param[2].uv32bit, (const GLint *)param[3].ptr);
}

void STUB_glMultiTexRenderbufferEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glMultiTexRenderbufferEXT( GLenum, GLenum, GLuint )
    maxParam = 3;
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_ENUM_PARAM(2);
    TR.skipLine();
    CHECK_USER_CALL(glMultiTexRenderbufferEXT)
        UCT.glMultiTexRenderbufferEXT(param[0].uv32bit, param[1].uv32bit, param[2].uv32bit);
    CHECK_GL_CALL(glMultiTexRenderbufferEXT)
        JT.glMultiTexRenderbufferEXT(param[0].uv32bit, param[1].uv32bit, param[2].uv32bit);
}

void STUB_glMultiTexSubImage1DEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glMultiTexSubImage1DEXT( GLenum, GLenum, GLint, GLint, GLsizei, GLenum, GLenum, const GLvoid * )
    maxParam = 8;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_PARAM(v32bit,2);
    READ_PARAM(v32bit,3);
    READ_PARAM(v32bit,4);
    READ_ENUM_PARAM(5);
    READ_ENUM_PARAM(6);
    READ_ARRAY_PARAM( 7, buffer0, TraceReader::TEXT_IGNORE);
    TR.skipLine();
    CHECK_USER_CALL(glMultiTexSubImage1DEXT)
        UCT.glMultiTexSubImage1DEXT(param[0].uv32bit, param[1].uv32bit, param[2].v32bit, param[3].v32bit, param[4].v32bit, param[5].uv32bit, param[6].uv32bit, (const GLvoid *)param[7].ptr);
    CHECK_GL_CALL(glMultiTexSubImage1DEXT)
        JT.glMultiTexSubImage1DEXT(param[0].uv32bit, param[1].uv32bit, param[2].v32bit, param[3].v32bit, param[4].v32bit, param[5].uv32bit, param[6].uv32bit, (const GLvoid *)param[7].ptr);
}

void STUB_glMultiTexSubImage2DEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glMultiTexSubImage2DEXT( GLenum, GLenum, GLint, GLint, GLint, GLsizei, GLsizei, GLenum, GLenum, const GLvoid * )
    maxParam = 10;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_PARAM(v32bit,2);
    READ_PARAM(v32bit,3);
    READ_PARAM(v32bit,4);
    READ_PARAM(v32bit,5);
    READ_PARAM(v32bit,6);
    READ_ENUM_PARAM(7);
    READ_ENUM_PARAM(8);
    READ_ARRAY_PARAM( 9, buffer0, TraceReader::TEXT_IGNORE);
    TR.skipLine();
    CHECK_USER_CALL(glMultiTexSubImage2DEXT)
        UCT.glMultiTexSubImage2DEXT(param[0].uv32bit, param[1].uv32bit, param[2].v32bit, param[3].v32bit, param[4].v32bit, param[5].v32bit, param[6].v32bit, param[7].uv32bit, param[8].uv32bit, (const GLvoid *)param[9].ptr);
    CHECK_GL_CALL(glMultiTexSubImage2DEXT)
        JT.glMultiTexSubImage2DEXT(param[0].uv32bit, param[1].uv32bit, param[2].v32bit, param[3].v32bit, param[4].v32bit, param[5].v32bit, param[6].v32bit, param[7].uv32bit, param[8].uv32bit, (const GLvoid *)param[9].ptr);
}

void STUB_glMultiTexSubImage3DEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glMultiTexSubImage3DEXT( GLenum, GLenum, GLint, GLint, GLint, GLint, GLsizei, GLsizei, GLsizei, GLenum, GLenum, const GLvoid * )
    maxParam = 12;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_PARAM(v32bit,2);
    READ_PARAM(v32bit,3);
    READ_PARAM(v32bit,4);
    READ_PARAM(v32bit,5);
    READ_PARAM(v32bit,6);
    READ_PARAM(v32bit,7);
    READ_PARAM(v32bit,8);
    READ_ENUM_PARAM(9);
    READ_ENUM_PARAM(10);
    READ_ARRAY_PARAM( 11, buffer0, TraceReader::TEXT_IGNORE);
    TR.skipLine();
    CHECK_USER_CALL(glMultiTexSubImage3DEXT)
        UCT.glMultiTexSubImage3DEXT(param[0].uv32bit, param[1].uv32bit, param[2].v32bit, param[3].v32bit, param[4].v32bit, param[5].v32bit, param[6].v32bit, param[7].v32bit, param[8].v32bit, param[9].uv32bit, param[10].uv32bit, (const GLvoid *)param[11].ptr);
    CHECK_GL_CALL(glMultiTexSubImage3DEXT)
        JT.glMultiTexSubImage3DEXT(param[0].uv32bit, param[1].uv32bit, param[2].v32bit, param[3].v32bit, param[4].v32bit, param[5].v32bit, param[6].v32bit, param[7].v32bit, param[8].v32bit, param[9].uv32bit, param[10].uv32bit, (const GLvoid *)param[11].ptr);
}

void STUB_glNamedBufferDataEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glNamedBufferDataEXT( GLuint, GLsizeiptr, const GLvoid *, GLenum )
    maxParam = 4;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_PARAM(v32bit,1);
    READ_ARRAY_PARAM( 2, buffer0, TraceReader::TEXT_IGNORE);
    READ_ENUM_PARAM(3);
    TR.skipLine();
    CHECK_USER_CALL(glNamedBufferDataEXT)
        UCT.glNamedBufferDataEXT(param[0].uv32bit, param[1].v32bit, (const GLvoid *)param[2].ptr, param[3].uv32bit);
    CHECK_GL_CALL(glNamedBufferDataEXT)
        JT.glNamedBufferDataEXT(param[0].uv32bit, param[1].v32bit, (const GLvoid *)param[2].ptr, param[3].uv32bit);
}

void STUB_glNamedBufferSubDataEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glNamedBufferSubDataEXT( GLuint, GLintptr, GLsizeiptr, const GLvoid * )
    maxParam = 4;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_PARAM(v32bit,1);
    READ_PARAM(v32bit,2);
    READ_ARRAY_PARAM( 3, buffer0, TraceReader::TEXT_IGNORE);
    TR.skipLine();
    CHECK_USER_CALL(glNamedBufferSubDataEXT)
        UCT.glNamedBufferSubDataEXT(param[0].uv32bit, param[1].v32bit, param[2].v32bit, (const GLvoid *)param[3].ptr);
    CHECK_GL_CALL(glNamedBufferSubDataEXT)
        JT.glNamedBufferSubDataEXT(param[0].uv32bit, param[1].v32bit, param[2].v32bit, (const GLvoid *)param[3].ptr);
}

void STUB_glNamedFramebufferRenderbufferEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glNamedFramebufferRenderbufferEXT( GLuint, GLenum, GLenum, GLuint )
    maxParam = 4;
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_ENUM_PARAM(2);
    READ_ENUM_PARAM(3);
    TR.skipLine();
    CHECK_USER_CALL(glNamedFramebufferRenderbufferEXT)
        UCT.glNamedFramebufferRenderbufferEXT(param[0].uv32bit, param[1].uv32bit, param[2].uv32bit, param[3].uv32bit);
    CHECK_GL_CALL(glNamedFramebufferRenderbufferEXT)
        JT.glNamedFramebufferRenderbufferEXT(param[0].uv32bit, param[1].uv32bit, param[2].uv32bit, param[3].uv32bit);
}

void STUB_glNamedFramebufferTexture1DEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glNamedFramebufferTexture1DEXT( GLuint, GLenum, GLenum, GLuint, GLint )
    maxParam = 5;
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_ENUM_PARAM(2);
    READ_ENUM_PARAM(3);
    READ_PARAM(v32bit,4);
    TR.skipLine();
    CHECK_USER_CALL(glNamedFramebufferTexture1DEXT)
        UCT.glNamedFramebufferTexture1DEXT(param[0].uv32bit, param[1].uv32bit, param[2].uv32bit, param[3].uv32bit, param[4].v32bit);
    CHECK_GL_CALL(glNamedFramebufferTexture1DEXT)
        JT.glNamedFramebufferTexture1DEXT(param[0].uv32bit, param[1].uv32bit, param[2].uv32bit, param[3].uv32bit, param[4].v32bit);
}

void STUB_glNamedFramebufferTexture2DEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glNamedFramebufferTexture2DEXT( GLuint, GLenum, GLenum, GLuint, GLint )
    maxParam = 5;
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_ENUM_PARAM(2);
    READ_ENUM_PARAM(3);
    READ_PARAM(v32bit,4);
    TR.skipLine();
    CHECK_USER_CALL(glNamedFramebufferTexture2DEXT)
        UCT.glNamedFramebufferTexture2DEXT(param[0].uv32bit, param[1].uv32bit, param[2].uv32bit, param[3].uv32bit, param[4].v32bit);
    CHECK_GL_CALL(glNamedFramebufferTexture2DEXT)
        JT.glNamedFramebufferTexture2DEXT(param[0].uv32bit, param[1].uv32bit, param[2].uv32bit, param[3].uv32bit, param[4].v32bit);
}

void STUB_glNamedFramebufferTexture3DEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glNamedFramebufferTexture3DEXT( GLuint, GLenum, GLenum, GLuint, GLint, GLint )
    maxParam = 6;
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_ENUM_PARAM(2);
    READ_ENUM_PARAM(3);
    READ_PARAM(v32bit,4);
    READ_PARAM(v32bit,5);
    TR.skipLine();
    CHECK_USER_CALL(glNamedFramebufferTexture3DEXT)
        UCT.glNamedFramebufferTexture3DEXT(param[0].uv32bit, param[1].uv32bit, param[2].uv32bit, param[3].uv32bit, param[4].v32bit, param[5].v32bit);
    CHECK_GL_CALL(glNamedFramebufferTexture3DEXT)
        JT.glNamedFramebufferTexture3DEXT(param[0].uv32bit, param[1].uv32bit, param[2].uv32bit, param[3].uv32bit, param[4].v32bit, param[5].v32bit);
}

void STUB_glNamedFramebufferTextureEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glNamedFramebufferTextureEXT( GLuint, GLenum, GLuint, GLint )
    maxParam = 4;
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_ENUM_PARAM(2);
    READ_PARAM(v32bit,3);
    TR.skipLine();
    CHECK_USER_CALL(glNamedFramebufferTextureEXT)
        UCT.glNamedFramebufferTextureEXT(param[0].uv32bit, param[1].uv32bit, param[2].uv32bit, param[3].v32bit);
    CHECK_GL_CALL(glNamedFramebufferTextureEXT)
        JT.glNamedFramebufferTextureEXT(param[0].uv32bit, param[1].uv32bit, param[2].uv32bit, param[3].v32bit);
}

void STUB_glNamedFramebufferTextureFaceEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glNamedFramebufferTextureFaceEXT( GLuint, GLenum, GLuint, GLint, GLenum )
    maxParam = 5;
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_ENUM_PARAM(2);
    READ_PARAM(v32bit,3);
    READ_ENUM_PARAM(4);
    TR.skipLine();
    CHECK_USER_CALL(glNamedFramebufferTextureFaceEXT)
        UCT.glNamedFramebufferTextureFaceEXT(param[0].uv32bit, param[1].uv32bit, param[2].uv32bit, param[3].v32bit, param[4].uv32bit);
    CHECK_GL_CALL(glNamedFramebufferTextureFaceEXT)
        JT.glNamedFramebufferTextureFaceEXT(param[0].uv32bit, param[1].uv32bit, param[2].uv32bit, param[3].v32bit, param[4].uv32bit);
}

void STUB_glNamedFramebufferTextureLayerEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glNamedFramebufferTextureLayerEXT( GLuint, GLenum, GLuint, GLint, GLint )
    maxParam = 5;
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_ENUM_PARAM(2);
    READ_PARAM(v32bit,3);
    READ_PARAM(v32bit,4);
    TR.skipLine();
    CHECK_USER_CALL(glNamedFramebufferTextureLayerEXT)
        UCT.glNamedFramebufferTextureLayerEXT(param[0].uv32bit, param[1].uv32bit, param[2].uv32bit, param[3].v32bit, param[4].v32bit);
    CHECK_GL_CALL(glNamedFramebufferTextureLayerEXT)
        JT.glNamedFramebufferTextureLayerEXT(param[0].uv32bit, param[1].uv32bit, param[2].uv32bit, param[3].v32bit, param[4].v32bit);
}

void STUB_glNamedProgramLocalParameter4dEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glNamedProgramLocalParameter4dEXT( GLuint, GLenum, GLuint, GLdouble, GLdouble, GLdouble, GLdouble )
    maxParam = 7;
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_ENUM_PARAM(2);
    READ_DOUBLE_PARAM(3);
    READ_DOUBLE_PARAM(4);
    READ_DOUBLE_PARAM(5);
    READ_DOUBLE_PARAM(6);
    TR.skipLine();
    CHECK_USER_CALL(glNamedProgramLocalParameter4dEXT)
        UCT.glNamedProgramLocalParameter4dEXT(param[0].uv32bit, param[1].uv32bit, param[2].uv32bit, param[3].fv64bit, param[4].fv64bit, param[5].fv64bit, param[6].fv64bit);
    CHECK_GL_CALL(glNamedProgramLocalParameter4dEXT)
        JT.glNamedProgramLocalParameter4dEXT(param[0].uv32bit, param[1].uv32bit, param[2].uv32bit, param[3].fv64bit, param[4].fv64bit, param[5].fv64bit, param[6].fv64bit);
}

void STUB_glNamedProgramLocalParameter4dvEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glNamedProgramLocalParameter4dvEXT( GLuint, GLenum, GLuint, const GLdouble * )
    maxParam = 4;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_ENUM_PARAM(2);
    READ_ARRAY_PARAM( 3, buffer0, TraceReader::TEXT_DOUBLE);
    TR.skipLine();
    CHECK_USER_CALL(glNamedProgramLocalParameter4dvEXT)
        UCT.glNamedProgramLocalParameter4dvEXT(param[0].uv32bit, param[1].uv32bit, param[2].uv32bit, (const GLdouble *)param[3].ptr);
    CHECK_GL_CALL(glNamedProgramLocalParameter4dvEXT)
        JT.glNamedProgramLocalParameter4dvEXT(param[0].uv32bit, param[1].uv32bit, param[2].uv32bit, (const GLdouble *)param[3].ptr);
}

void STUB_glNamedProgramLocalParameter4fEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glNamedProgramLocalParameter4fEXT( GLuint, GLenum, GLuint, GLfloat, GLfloat, GLfloat, GLfloat )
    maxParam = 7;
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_ENUM_PARAM(2);
    READ_PARAM(fv32bit,3);
    READ_PARAM(fv32bit,4);
    READ_PARAM(fv32bit,5);
    READ_PARAM(fv32bit,6);
    TR.skipLine();
    CHECK_USER_CALL(glNamedProgramLocalParameter4fEXT)
        UCT.glNamedProgramLocalParameter4fEXT(param[0].uv32bit, param[1].uv32bit, param[2].uv32bit, param[3].fv32bit, param[4].fv32bit, param[5].fv32bit, param[6].fv32bit);
    CHECK_GL_CALL(glNamedProgramLocalParameter4fEXT)
        JT.glNamedProgramLocalParameter4fEXT(param[0].uv32bit, param[1].uv32bit, param[2].uv32bit, param[3].fv32bit, param[4].fv32bit, param[5].fv32bit, param[6].fv32bit);
}

void STUB_glNamedProgramLocalParameter4fvEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glNamedProgramLocalParameter4fvEXT( GLuint, GLenum, GLuint, const GLfloat * )
    maxParam = 4;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_ENUM_PARAM(2);
    READ_ARRAY_PARAM( 3, buffer0, TraceReader::TEXT_FLOAT);
    TR.skipLine();
    CHECK_USER_CALL(glNamedProgramLocalParameter4fvEXT)
        UCT.glNamedProgramLocalParameter4fvEXT(param[0].uv32bit, param[1].uv32bit, param[2].uv32bit, (const GLfloat *)param[3].ptr);
    CHECK_GL_CALL(glNamedProgramLocalParameter4fvEXT)
        JT.glNamedProgramLocalParameter4fvEXT(param[0].uv32bit, param[1].uv32bit, param[2].uv32bit, (const GLfloat *)param[3].ptr);
}

void STUB_glNamedProgramLocalParameterI4iEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glNamedProgramLocalParameterI4iEXT( GLuint, GLenum, GLuint, GLint, GLint, GLint, GLint )
    maxParam = 7;
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_ENUM_PARAM(2);
    READ_PARAM(v32bit,3);
    READ_PARAM(v32bit,4);
    READ_PARAM(v32bit,5);
    READ_PARAM(v32bit,6);
    TR.skipLine();
    CHECK_USER_CALL(glNamedProgramLocalParameterI4iEXT)
        UCT.glNamedProgramLocalParameterI4iEXT(param[0].uv32bit, param[1].uv32bit, param[2].uv32bit, param[3].v32bit, param[4].v32bit, param[5].v32bit, param[6].v32bit);
    CHECK_GL_CALL(glNamedProgramLocalParameterI4iEXT)
        JT.glNamedProgramLocalParameterI4iEXT(param[0].uv32bit, param[1].uv32bit, param[2].uv32bit, param[3].v32bit, param[4].v32bit, param[5].v32bit, param[6].v32bit);
}

void STUB_glNamedProgramLocalParameterI4ivEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glNamedProgramLocalParameterI4ivEXT( GLuint, GLenum, GLuint, const GLint * )
    maxParam = 4;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_ENUM_PARAM(2);
    READ_ARRAY_PARAM( 3, buffer0, TraceReader::TEXT_INT);
    TR.skipLine();
    CHECK_USER_CALL(glNamedProgramLocalParameterI4ivEXT)
        UCT.glNamedProgramLocalParameterI4ivEXT(param[0].uv32bit, param[1].uv32bit, param[2].uv32bit, (const GLint *)param[3].ptr);
    CHECK_GL_CALL(glNamedProgramLocalParameterI4ivEXT)
        JT.glNamedProgramLocalParameterI4ivEXT(param[0].uv32bit, param[1].uv32bit, param[2].uv32bit, (const GLint *)param[3].ptr);
}

void STUB_glNamedProgramLocalParameterI4uiEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glNamedProgramLocalParameterI4uiEXT( GLuint, GLenum, GLuint, GLuint, GLuint, GLuint, GLuint )
    maxParam = 7;
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_ENUM_PARAM(2);
    READ_ENUM_PARAM(3);
    READ_ENUM_PARAM(4);
    READ_ENUM_PARAM(5);
    READ_ENUM_PARAM(6);
    TR.skipLine();
    CHECK_USER_CALL(glNamedProgramLocalParameterI4uiEXT)
        UCT.glNamedProgramLocalParameterI4uiEXT(param[0].uv32bit, param[1].uv32bit, param[2].uv32bit, param[3].uv32bit, param[4].uv32bit, param[5].uv32bit, param[6].uv32bit);
    CHECK_GL_CALL(glNamedProgramLocalParameterI4uiEXT)
        JT.glNamedProgramLocalParameterI4uiEXT(param[0].uv32bit, param[1].uv32bit, param[2].uv32bit, param[3].uv32bit, param[4].uv32bit, param[5].uv32bit, param[6].uv32bit);
}

void STUB_glNamedProgramLocalParameterI4uivEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glNamedProgramLocalParameterI4uivEXT( GLuint, GLenum, GLuint, const GLuint * )
    maxParam = 4;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_ENUM_PARAM(2);
    READ_ARRAY_PARAM( 3, buffer0, TraceReader::TEXT_INT);
    TR.skipLine();
    CHECK_USER_CALL(glNamedProgramLocalParameterI4uivEXT)
        UCT.glNamedProgramLocalParameterI4uivEXT(param[0].uv32bit, param[1].uv32bit, param[2].uv32bit, (const GLuint *)param[3].ptr);
    CHECK_GL_CALL(glNamedProgramLocalParameterI4uivEXT)
        JT.glNamedProgramLocalParameterI4uivEXT(param[0].uv32bit, param[1].uv32bit, param[2].uv32bit, (const GLuint *)param[3].ptr);
}

void STUB_glNamedProgramLocalParameters4fvEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glNamedProgramLocalParameters4fvEXT( GLuint, GLenum, GLuint, GLsizei, const GLfloat * )
    maxParam = 5;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_ENUM_PARAM(2);
    READ_PARAM(v32bit,3);
    READ_ARRAY_PARAM( 4, buffer0, TraceReader::TEXT_FLOAT);
    TR.skipLine();
    CHECK_USER_CALL(glNamedProgramLocalParameters4fvEXT)
        UCT.glNamedProgramLocalParameters4fvEXT(param[0].uv32bit, param[1].uv32bit, param[2].uv32bit, param[3].v32bit, (const GLfloat *)param[4].ptr);
    CHECK_GL_CALL(glNamedProgramLocalParameters4fvEXT)
        JT.glNamedProgramLocalParameters4fvEXT(param[0].uv32bit, param[1].uv32bit, param[2].uv32bit, param[3].v32bit, (const GLfloat *)param[4].ptr);
}

void STUB_glNamedProgramLocalParametersI4ivEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glNamedProgramLocalParametersI4ivEXT( GLuint, GLenum, GLuint, GLsizei, const GLint * )
    maxParam = 5;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_ENUM_PARAM(2);
    READ_PARAM(v32bit,3);
    READ_ARRAY_PARAM( 4, buffer0, TraceReader::TEXT_INT);
    TR.skipLine();
    CHECK_USER_CALL(glNamedProgramLocalParametersI4ivEXT)
        UCT.glNamedProgramLocalParametersI4ivEXT(param[0].uv32bit, param[1].uv32bit, param[2].uv32bit, param[3].v32bit, (const GLint *)param[4].ptr);
    CHECK_GL_CALL(glNamedProgramLocalParametersI4ivEXT)
        JT.glNamedProgramLocalParametersI4ivEXT(param[0].uv32bit, param[1].uv32bit, param[2].uv32bit, param[3].v32bit, (const GLint *)param[4].ptr);
}

void STUB_glNamedProgramLocalParametersI4uivEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glNamedProgramLocalParametersI4uivEXT( GLuint, GLenum, GLuint, GLsizei, const GLuint * )
    maxParam = 5;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_ENUM_PARAM(2);
    READ_PARAM(v32bit,3);
    READ_ARRAY_PARAM( 4, buffer0, TraceReader::TEXT_INT);
    TR.skipLine();
    CHECK_USER_CALL(glNamedProgramLocalParametersI4uivEXT)
        UCT.glNamedProgramLocalParametersI4uivEXT(param[0].uv32bit, param[1].uv32bit, param[2].uv32bit, param[3].v32bit, (const GLuint *)param[4].ptr);
    CHECK_GL_CALL(glNamedProgramLocalParametersI4uivEXT)
        JT.glNamedProgramLocalParametersI4uivEXT(param[0].uv32bit, param[1].uv32bit, param[2].uv32bit, param[3].v32bit, (const GLuint *)param[4].ptr);
}

void STUB_glNamedProgramStringEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glNamedProgramStringEXT( GLuint, GLenum, GLenum, GLsizei, const GLvoid * )
    maxParam = 5;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_ENUM_PARAM(2);
    READ_PARAM(v32bit,3);
    READ_ARRAY_PARAM( 4, buffer0, TraceReader::TEXT_IGNORE);
    TR.skipLine();
    CHECK_USER_CALL(glNamedProgramStringEXT)
        UCT.glNamedProgramStringEXT(param[0].uv32bit, param[1].uv32bit, param[2].uv32bit, param[3].v32bit, (const GLvoid *)param[4].ptr);
    CHECK_GL_CALL(glNamedProgramStringEXT)
        JT.glNamedProgramStringEXT(param[0].uv32bit, param[1].uv32bit, param[2].uv32bit, param[3].v32bit, (const GLvoid *)param[4].ptr);
}

void STUB_glNamedRenderbufferStorageEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glNamedRenderbufferStorageEXT( GLuint, GLenum, GLsizei, GLsizei )
    maxParam = 4;
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_PARAM(v32bit,2);
    READ_PARAM(v32bit,3);
    TR.skipLine();
    CHECK_USER_CALL(glNamedRenderbufferStorageEXT)
        UCT.glNamedRenderbufferStorageEXT(param[0].uv32bit, param[1].uv32bit, param[2].v32bit, param[3].v32bit);
    CHECK_GL_CALL(glNamedRenderbufferStorageEXT)
        JT.glNamedRenderbufferStorageEXT(param[0].uv32bit, param[1].uv32bit, param[2].v32bit, param[3].v32bit);
}

void STUB_glNamedRenderbufferStorageMultisampleCoverageEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glNamedRenderbufferStorageMultisampleCoverageEXT( GLuint, GLsizei, GLsizei, GLenum, GLsizei, GLsizei )
    maxParam = 6;
    READ_ENUM_PARAM(0);
    READ_PARAM(v32bit,1);
    READ_PARAM(v32bit,2);
    READ_ENUM_PARAM(3);
    READ_PARAM(v32bit,4);
    READ_PARAM(v32bit,5);
    TR.skipLine();
    CHECK_USER_CALL(glNamedRenderbufferStorageMultisampleCoverageEXT)
        UCT.glNamedRenderbufferStorageMultisampleCoverageEXT(param[0].uv32bit, param[1].v32bit, param[2].v32bit, param[3].uv32bit, param[4].v32bit, param[5].v32bit);
    CHECK_GL_CALL(glNamedRenderbufferStorageMultisampleCoverageEXT)
        JT.glNamedRenderbufferStorageMultisampleCoverageEXT(param[0].uv32bit, param[1].v32bit, param[2].v32bit, param[3].uv32bit, param[4].v32bit, param[5].v32bit);
}

void STUB_glNamedRenderbufferStorageMultisampleEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glNamedRenderbufferStorageMultisampleEXT( GLuint, GLsizei, GLenum, GLsizei, GLsizei )
    maxParam = 5;
    READ_ENUM_PARAM(0);
    READ_PARAM(v32bit,1);
    READ_ENUM_PARAM(2);
    READ_PARAM(v32bit,3);
    READ_PARAM(v32bit,4);
    TR.skipLine();
    CHECK_USER_CALL(glNamedRenderbufferStorageMultisampleEXT)
        UCT.glNamedRenderbufferStorageMultisampleEXT(param[0].uv32bit, param[1].v32bit, param[2].uv32bit, param[3].v32bit, param[4].v32bit);
    CHECK_GL_CALL(glNamedRenderbufferStorageMultisampleEXT)
        JT.glNamedRenderbufferStorageMultisampleEXT(param[0].uv32bit, param[1].v32bit, param[2].uv32bit, param[3].v32bit, param[4].v32bit);
}

void STUB_glNewList( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glNewList( GLuint list, GLenum mode )
    maxParam = 2;
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    TR.skipLine();
    CHECK_USER_CALL(glNewList)
        UCT.glNewList(param[0].uv32bit, param[1].uv32bit);
    CHECK_GL_CALL(glNewList)
        JT.glNewList(param[0].uv32bit, param[1].uv32bit);
}

void STUB_glNewObjectBufferATI( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // GLuint glNewObjectBufferATI( GLsizei, const GLvoid *, GLenum )
    maxParam = 3;
    char buffer0[16*4096];
    READ_PARAM(v32bit,0);
    READ_ARRAY_PARAM( 1, buffer0, TraceReader::TEXT_IGNORE);
    READ_ENUM_PARAM(2);
    TR.skipResult();
    TR.skipLine();
    CHECK_USER_CALL(glNewObjectBufferATI)
        UCT.glNewObjectBufferATI(param[0].v32bit, (const GLvoid *)param[1].ptr, param[2].uv32bit);
    CHECK_GL_CALL(glNewObjectBufferATI)
        JT.glNewObjectBufferATI(param[0].v32bit, (const GLvoid *)param[1].ptr, param[2].uv32bit);
}

void STUB_glNormal3b( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glNormal3b( GLbyte nx, GLbyte ny, GLbyte nz )
    maxParam = 3;
    READ_PARAM(v8bit,0);
    READ_PARAM(v8bit,1);
    READ_PARAM(v8bit,2);
    TR.skipLine();
    CHECK_USER_CALL(glNormal3b)
        UCT.glNormal3b(param[0].v8bit, param[1].v8bit, param[2].v8bit);
    CHECK_GL_CALL(glNormal3b)
        JT.glNormal3b(param[0].v8bit, param[1].v8bit, param[2].v8bit);
}

void STUB_glNormal3bv( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glNormal3bv( const GLbyte *v )
    maxParam = 1;
    char buffer0[16*4096];
    READ_ARRAY_PARAM( 0, buffer0, TraceReader::TEXT_BYTE);
    TR.skipLine();
    CHECK_USER_CALL(glNormal3bv)
        UCT.glNormal3bv((const GLbyte *)param[0].ptr);
    CHECK_GL_CALL(glNormal3bv)
        JT.glNormal3bv((const GLbyte *)param[0].ptr);
}

void STUB_glNormal3d( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glNormal3d( GLdouble nx, GLdouble ny, GLdouble nz )
    maxParam = 3;
    READ_DOUBLE_PARAM(0);
    READ_DOUBLE_PARAM(1);
    READ_DOUBLE_PARAM(2);
    TR.skipLine();
    CHECK_USER_CALL(glNormal3d)
        UCT.glNormal3d(param[0].fv64bit, param[1].fv64bit, param[2].fv64bit);
    CHECK_GL_CALL(glNormal3d)
        JT.glNormal3d(param[0].fv64bit, param[1].fv64bit, param[2].fv64bit);
}

void STUB_glNormal3dv( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glNormal3dv( const GLdouble *v )
    maxParam = 1;
    char buffer0[16*4096];
    READ_ARRAY_PARAM( 0, buffer0, TraceReader::TEXT_DOUBLE);
    TR.skipLine();
    CHECK_USER_CALL(glNormal3dv)
        UCT.glNormal3dv((const GLdouble *)param[0].ptr);
    CHECK_GL_CALL(glNormal3dv)
        JT.glNormal3dv((const GLdouble *)param[0].ptr);
}

void STUB_glNormal3f( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glNormal3f( GLfloat nx, GLfloat ny, GLfloat nz )
    maxParam = 3;
    READ_PARAM(fv32bit,0);
    READ_PARAM(fv32bit,1);
    READ_PARAM(fv32bit,2);
    TR.skipLine();
    CHECK_USER_CALL(glNormal3f)
        UCT.glNormal3f(param[0].fv32bit, param[1].fv32bit, param[2].fv32bit);
    CHECK_GL_CALL(glNormal3f)
        JT.glNormal3f(param[0].fv32bit, param[1].fv32bit, param[2].fv32bit);
}

void STUB_glNormal3fv( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glNormal3fv( const GLfloat *v )
    maxParam = 1;
    char buffer0[16*4096];
    READ_ARRAY_PARAM( 0, buffer0, TraceReader::TEXT_FLOAT);
    TR.skipLine();
    CHECK_USER_CALL(glNormal3fv)
        UCT.glNormal3fv((const GLfloat *)param[0].ptr);
    CHECK_GL_CALL(glNormal3fv)
        JT.glNormal3fv((const GLfloat *)param[0].ptr);
}

void STUB_glNormal3hNV( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glNormal3hNV( GLhalfNV, GLhalfNV, GLhalfNV )
    // Call not playable
    TR.skipCall();
}

void STUB_glNormal3hvNV( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glNormal3hvNV( const GLhalfNV * )
    // Call not playable
    TR.skipCall();
}

void STUB_glNormal3i( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glNormal3i( GLint nx, GLint ny, GLint nz )
    maxParam = 3;
    READ_PARAM(v32bit,0);
    READ_PARAM(v32bit,1);
    READ_PARAM(v32bit,2);
    TR.skipLine();
    CHECK_USER_CALL(glNormal3i)
        UCT.glNormal3i(param[0].v32bit, param[1].v32bit, param[2].v32bit);
    CHECK_GL_CALL(glNormal3i)
        JT.glNormal3i(param[0].v32bit, param[1].v32bit, param[2].v32bit);
}

void STUB_glNormal3iv( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glNormal3iv( const GLint *v )
    maxParam = 1;
    char buffer0[16*4096];
    READ_ARRAY_PARAM( 0, buffer0, TraceReader::TEXT_INT);
    TR.skipLine();
    CHECK_USER_CALL(glNormal3iv)
        UCT.glNormal3iv((const GLint *)param[0].ptr);
    CHECK_GL_CALL(glNormal3iv)
        JT.glNormal3iv((const GLint *)param[0].ptr);
}

void STUB_glNormal3s( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glNormal3s( GLshort nx, GLshort ny, GLshort nz )
    maxParam = 3;
    READ_PARAM(v16bit,0);
    READ_PARAM(v16bit,1);
    READ_PARAM(v16bit,2);
    TR.skipLine();
    CHECK_USER_CALL(glNormal3s)
        UCT.glNormal3s(param[0].v16bit, param[1].v16bit, param[2].v16bit);
    CHECK_GL_CALL(glNormal3s)
        JT.glNormal3s(param[0].v16bit, param[1].v16bit, param[2].v16bit);
}

void STUB_glNormal3sv( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glNormal3sv( const GLshort *v )
    maxParam = 1;
    char buffer0[16*4096];
    READ_ARRAY_PARAM( 0, buffer0, TraceReader::TEXT_SHORT);
    TR.skipLine();
    CHECK_USER_CALL(glNormal3sv)
        UCT.glNormal3sv((const GLshort *)param[0].ptr);
    CHECK_GL_CALL(glNormal3sv)
        JT.glNormal3sv((const GLshort *)param[0].ptr);
}

void STUB_glNormalPointer( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glNormalPointer( GLenum type, GLsizei stride, const GLvoid *ptr )
    maxParam = 3;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_PARAM(v32bit,1);
    READ_ARRAY_PARAM( 2, buffer0, TraceReader::TEXT_IGNORE);
    TR.skipLine();
    CHECK_USER_CALL(glNormalPointer)
        UCT.glNormalPointer(param[0].uv32bit, param[1].v32bit, (const GLvoid *)param[2].ptr);
    CHECK_GL_CALL(glNormalPointer)
        JT.glNormalPointer(param[0].uv32bit, param[1].v32bit, (const GLvoid *)param[2].ptr);
}

void STUB_glNormalPointerEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glNormalPointerEXT( GLenum, GLsizei, GLsizei, const GLvoid * )
    maxParam = 4;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_PARAM(v32bit,1);
    READ_PARAM(v32bit,2);
    READ_ARRAY_PARAM( 3, buffer0, TraceReader::TEXT_IGNORE);
    TR.skipLine();
    CHECK_USER_CALL(glNormalPointerEXT)
        UCT.glNormalPointerEXT(param[0].uv32bit, param[1].v32bit, param[2].v32bit, (const GLvoid *)param[3].ptr);
    CHECK_GL_CALL(glNormalPointerEXT)
        JT.glNormalPointerEXT(param[0].uv32bit, param[1].v32bit, param[2].v32bit, (const GLvoid *)param[3].ptr);
}

void STUB_glNormalPointervINTEL( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glNormalPointervINTEL( GLenum, const GLvoid ** )
    maxParam = 2;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ARRAY_PARAM( 1, buffer0, TraceReader::TEXT_IGNORE);
    TR.skipLine();
    CHECK_USER_CALL(glNormalPointervINTEL)
        UCT.glNormalPointervINTEL(param[0].uv32bit, (const GLvoid **)param[1].ptr);
    CHECK_GL_CALL(glNormalPointervINTEL)
        JT.glNormalPointervINTEL(param[0].uv32bit, (const GLvoid **)param[1].ptr);
}

void STUB_glNormalStream3bATI( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glNormalStream3bATI( GLenum, GLbyte, GLbyte, GLbyte )
    maxParam = 4;
    READ_ENUM_PARAM(0);
    READ_PARAM(v8bit,1);
    READ_PARAM(v8bit,2);
    READ_PARAM(v8bit,3);
    TR.skipLine();
    CHECK_USER_CALL(glNormalStream3bATI)
        UCT.glNormalStream3bATI(param[0].uv32bit, param[1].v8bit, param[2].v8bit, param[3].v8bit);
    CHECK_GL_CALL(glNormalStream3bATI)
        JT.glNormalStream3bATI(param[0].uv32bit, param[1].v8bit, param[2].v8bit, param[3].v8bit);
}

void STUB_glNormalStream3bvATI( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glNormalStream3bvATI( GLenum, const GLbyte * )
    maxParam = 2;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ARRAY_PARAM( 1, buffer0, TraceReader::TEXT_BYTE);
    TR.skipLine();
    CHECK_USER_CALL(glNormalStream3bvATI)
        UCT.glNormalStream3bvATI(param[0].uv32bit, (const GLbyte *)param[1].ptr);
    CHECK_GL_CALL(glNormalStream3bvATI)
        JT.glNormalStream3bvATI(param[0].uv32bit, (const GLbyte *)param[1].ptr);
}

void STUB_glNormalStream3dATI( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glNormalStream3dATI( GLenum, GLdouble, GLdouble, GLdouble )
    maxParam = 4;
    READ_ENUM_PARAM(0);
    READ_DOUBLE_PARAM(1);
    READ_DOUBLE_PARAM(2);
    READ_DOUBLE_PARAM(3);
    TR.skipLine();
    CHECK_USER_CALL(glNormalStream3dATI)
        UCT.glNormalStream3dATI(param[0].uv32bit, param[1].fv64bit, param[2].fv64bit, param[3].fv64bit);
    CHECK_GL_CALL(glNormalStream3dATI)
        JT.glNormalStream3dATI(param[0].uv32bit, param[1].fv64bit, param[2].fv64bit, param[3].fv64bit);
}

void STUB_glNormalStream3dvATI( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glNormalStream3dvATI( GLenum, const GLdouble * )
    maxParam = 2;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ARRAY_PARAM( 1, buffer0, TraceReader::TEXT_DOUBLE);
    TR.skipLine();
    CHECK_USER_CALL(glNormalStream3dvATI)
        UCT.glNormalStream3dvATI(param[0].uv32bit, (const GLdouble *)param[1].ptr);
    CHECK_GL_CALL(glNormalStream3dvATI)
        JT.glNormalStream3dvATI(param[0].uv32bit, (const GLdouble *)param[1].ptr);
}

void STUB_glNormalStream3fATI( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glNormalStream3fATI( GLenum, GLfloat, GLfloat, GLfloat )
    maxParam = 4;
    READ_ENUM_PARAM(0);
    READ_PARAM(fv32bit,1);
    READ_PARAM(fv32bit,2);
    READ_PARAM(fv32bit,3);
    TR.skipLine();
    CHECK_USER_CALL(glNormalStream3fATI)
        UCT.glNormalStream3fATI(param[0].uv32bit, param[1].fv32bit, param[2].fv32bit, param[3].fv32bit);
    CHECK_GL_CALL(glNormalStream3fATI)
        JT.glNormalStream3fATI(param[0].uv32bit, param[1].fv32bit, param[2].fv32bit, param[3].fv32bit);
}

void STUB_glNormalStream3fvATI( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glNormalStream3fvATI( GLenum, const GLfloat * )
    maxParam = 2;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ARRAY_PARAM( 1, buffer0, TraceReader::TEXT_FLOAT);
    TR.skipLine();
    CHECK_USER_CALL(glNormalStream3fvATI)
        UCT.glNormalStream3fvATI(param[0].uv32bit, (const GLfloat *)param[1].ptr);
    CHECK_GL_CALL(glNormalStream3fvATI)
        JT.glNormalStream3fvATI(param[0].uv32bit, (const GLfloat *)param[1].ptr);
}

void STUB_glNormalStream3iATI( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glNormalStream3iATI( GLenum, GLint, GLint, GLint )
    maxParam = 4;
    READ_ENUM_PARAM(0);
    READ_PARAM(v32bit,1);
    READ_PARAM(v32bit,2);
    READ_PARAM(v32bit,3);
    TR.skipLine();
    CHECK_USER_CALL(glNormalStream3iATI)
        UCT.glNormalStream3iATI(param[0].uv32bit, param[1].v32bit, param[2].v32bit, param[3].v32bit);
    CHECK_GL_CALL(glNormalStream3iATI)
        JT.glNormalStream3iATI(param[0].uv32bit, param[1].v32bit, param[2].v32bit, param[3].v32bit);
}

void STUB_glNormalStream3ivATI( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glNormalStream3ivATI( GLenum, const GLint * )
    maxParam = 2;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ARRAY_PARAM( 1, buffer0, TraceReader::TEXT_INT);
    TR.skipLine();
    CHECK_USER_CALL(glNormalStream3ivATI)
        UCT.glNormalStream3ivATI(param[0].uv32bit, (const GLint *)param[1].ptr);
    CHECK_GL_CALL(glNormalStream3ivATI)
        JT.glNormalStream3ivATI(param[0].uv32bit, (const GLint *)param[1].ptr);
}

void STUB_glNormalStream3sATI( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glNormalStream3sATI( GLenum, GLshort, GLshort, GLshort )
    maxParam = 4;
    READ_ENUM_PARAM(0);
    READ_PARAM(v16bit,1);
    READ_PARAM(v16bit,2);
    READ_PARAM(v16bit,3);
    TR.skipLine();
    CHECK_USER_CALL(glNormalStream3sATI)
        UCT.glNormalStream3sATI(param[0].uv32bit, param[1].v16bit, param[2].v16bit, param[3].v16bit);
    CHECK_GL_CALL(glNormalStream3sATI)
        JT.glNormalStream3sATI(param[0].uv32bit, param[1].v16bit, param[2].v16bit, param[3].v16bit);
}

void STUB_glNormalStream3svATI( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glNormalStream3svATI( GLenum, const GLshort * )
    maxParam = 2;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ARRAY_PARAM( 1, buffer0, TraceReader::TEXT_SHORT);
    TR.skipLine();
    CHECK_USER_CALL(glNormalStream3svATI)
        UCT.glNormalStream3svATI(param[0].uv32bit, (const GLshort *)param[1].ptr);
    CHECK_GL_CALL(glNormalStream3svATI)
        JT.glNormalStream3svATI(param[0].uv32bit, (const GLshort *)param[1].ptr);
}

void STUB_glOrtho( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glOrtho( GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble near_val, GLdouble far_val )
    maxParam = 6;
    READ_DOUBLE_PARAM(0);
    READ_DOUBLE_PARAM(1);
    READ_DOUBLE_PARAM(2);
    READ_DOUBLE_PARAM(3);
    READ_DOUBLE_PARAM(4);
    READ_DOUBLE_PARAM(5);
    TR.skipLine();
    CHECK_USER_CALL(glOrtho)
        UCT.glOrtho(param[0].fv64bit, param[1].fv64bit, param[2].fv64bit, param[3].fv64bit, param[4].fv64bit, param[5].fv64bit);
    CHECK_GL_CALL(glOrtho)
        JT.glOrtho(param[0].fv64bit, param[1].fv64bit, param[2].fv64bit, param[3].fv64bit, param[4].fv64bit, param[5].fv64bit);
}

void STUB_glPNTrianglesfATI( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glPNTrianglesfATI( GLenum, GLfloat )
    maxParam = 2;
    READ_ENUM_PARAM(0);
    READ_PARAM(fv32bit,1);
    TR.skipLine();
    CHECK_USER_CALL(glPNTrianglesfATI)
        UCT.glPNTrianglesfATI(param[0].uv32bit, param[1].fv32bit);
    CHECK_GL_CALL(glPNTrianglesfATI)
        JT.glPNTrianglesfATI(param[0].uv32bit, param[1].fv32bit);
}

void STUB_glPNTrianglesiATI( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glPNTrianglesiATI( GLenum, GLint )
    maxParam = 2;
    READ_ENUM_PARAM(0);
    READ_PARAM(v32bit,1);
    TR.skipLine();
    CHECK_USER_CALL(glPNTrianglesiATI)
        UCT.glPNTrianglesiATI(param[0].uv32bit, param[1].v32bit);
    CHECK_GL_CALL(glPNTrianglesiATI)
        JT.glPNTrianglesiATI(param[0].uv32bit, param[1].v32bit);
}

void STUB_glPassTexCoordATI( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glPassTexCoordATI( GLuint, GLuint, GLenum )
    maxParam = 3;
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_ENUM_PARAM(2);
    TR.skipLine();
    CHECK_USER_CALL(glPassTexCoordATI)
        UCT.glPassTexCoordATI(param[0].uv32bit, param[1].uv32bit, param[2].uv32bit);
    CHECK_GL_CALL(glPassTexCoordATI)
        JT.glPassTexCoordATI(param[0].uv32bit, param[1].uv32bit, param[2].uv32bit);
}

void STUB_glPassThrough( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glPassThrough( GLfloat token )
    maxParam = 1;
    READ_PARAM(fv32bit,0);
    TR.skipLine();
    CHECK_USER_CALL(glPassThrough)
        UCT.glPassThrough(param[0].fv32bit);
    CHECK_GL_CALL(glPassThrough)
        JT.glPassThrough(param[0].fv32bit);
}

void STUB_glPauseTransformFeedbackNV( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glPauseTransformFeedbackNV(  )
    maxParam = 0;
    TR.skipLine();
    CHECK_USER_CALL(glPauseTransformFeedbackNV)
        UCT.glPauseTransformFeedbackNV();
    CHECK_GL_CALL(glPauseTransformFeedbackNV)
        JT.glPauseTransformFeedbackNV();
}

void STUB_glPixelDataRangeNV( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glPixelDataRangeNV( GLenum, GLsizei, GLvoid * )
    maxParam = 3;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_PARAM(v32bit,1);
    READ_ARRAY_PARAM( 2, buffer0, TraceReader::TEXT_IGNORE);
    TR.skipLine();
    CHECK_USER_CALL(glPixelDataRangeNV)
        UCT.glPixelDataRangeNV(param[0].uv32bit, param[1].v32bit, (GLvoid *)param[2].ptr);
    CHECK_GL_CALL(glPixelDataRangeNV)
        JT.glPixelDataRangeNV(param[0].uv32bit, param[1].v32bit, (GLvoid *)param[2].ptr);
}

void STUB_glPixelMapfv( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glPixelMapfv( GLenum map, GLsizei mapsize, const GLfloat *values )
    maxParam = 3;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_PARAM(v32bit,1);
    READ_ARRAY_PARAM( 2, buffer0, TraceReader::TEXT_FLOAT);
    TR.skipLine();
    CHECK_USER_CALL(glPixelMapfv)
        UCT.glPixelMapfv(param[0].uv32bit, param[1].v32bit, (const GLfloat *)param[2].ptr);
    CHECK_GL_CALL(glPixelMapfv)
        JT.glPixelMapfv(param[0].uv32bit, param[1].v32bit, (const GLfloat *)param[2].ptr);
}

void STUB_glPixelMapuiv( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glPixelMapuiv( GLenum map, GLsizei mapsize, const GLuint *values )
    maxParam = 3;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_PARAM(v32bit,1);
    READ_ARRAY_PARAM( 2, buffer0, TraceReader::TEXT_INT);
    TR.skipLine();
    CHECK_USER_CALL(glPixelMapuiv)
        UCT.glPixelMapuiv(param[0].uv32bit, param[1].v32bit, (const GLuint *)param[2].ptr);
    CHECK_GL_CALL(glPixelMapuiv)
        JT.glPixelMapuiv(param[0].uv32bit, param[1].v32bit, (const GLuint *)param[2].ptr);
}

void STUB_glPixelMapusv( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glPixelMapusv( GLenum map, GLsizei mapsize, const GLushort *values )
    maxParam = 3;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_PARAM(v32bit,1);
    READ_ARRAY_PARAM( 2, buffer0, TraceReader::TEXT_SHORT);
    TR.skipLine();
    CHECK_USER_CALL(glPixelMapusv)
        UCT.glPixelMapusv(param[0].uv32bit, param[1].v32bit, (const GLushort *)param[2].ptr);
    CHECK_GL_CALL(glPixelMapusv)
        JT.glPixelMapusv(param[0].uv32bit, param[1].v32bit, (const GLushort *)param[2].ptr);
}

void STUB_glPixelStoref( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glPixelStoref( GLenum pname, GLfloat param )
    maxParam = 2;
    READ_ENUM_PARAM(0);
    READ_PARAM(fv32bit,1);
    TR.skipLine();
    CHECK_USER_CALL(glPixelStoref)
        UCT.glPixelStoref(param[0].uv32bit, param[1].fv32bit);
    CHECK_GL_CALL(glPixelStoref)
        JT.glPixelStoref(param[0].uv32bit, param[1].fv32bit);
}

void STUB_glPixelStorei( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glPixelStorei( GLenum pname, GLint param )
    maxParam = 2;
    READ_ENUM_PARAM(0);
    READ_PARAM(v32bit,1);
    TR.skipLine();
    CHECK_USER_CALL(glPixelStorei)
        UCT.glPixelStorei(param[0].uv32bit, param[1].v32bit);
    CHECK_GL_CALL(glPixelStorei)
        JT.glPixelStorei(param[0].uv32bit, param[1].v32bit);
}

void STUB_glPixelTexGenParameterfSGIS( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glPixelTexGenParameterfSGIS( GLenum, GLfloat )
    maxParam = 2;
    READ_ENUM_PARAM(0);
    READ_PARAM(fv32bit,1);
    TR.skipLine();
    CHECK_USER_CALL(glPixelTexGenParameterfSGIS)
        UCT.glPixelTexGenParameterfSGIS(param[0].uv32bit, param[1].fv32bit);
    CHECK_GL_CALL(glPixelTexGenParameterfSGIS)
        JT.glPixelTexGenParameterfSGIS(param[0].uv32bit, param[1].fv32bit);
}

void STUB_glPixelTexGenParameterfvSGIS( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glPixelTexGenParameterfvSGIS( GLenum, const GLfloat * )
    maxParam = 2;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ARRAY_PARAM( 1, buffer0, TraceReader::TEXT_FLOAT);
    TR.skipLine();
    CHECK_USER_CALL(glPixelTexGenParameterfvSGIS)
        UCT.glPixelTexGenParameterfvSGIS(param[0].uv32bit, (const GLfloat *)param[1].ptr);
    CHECK_GL_CALL(glPixelTexGenParameterfvSGIS)
        JT.glPixelTexGenParameterfvSGIS(param[0].uv32bit, (const GLfloat *)param[1].ptr);
}

void STUB_glPixelTexGenParameteriSGIS( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glPixelTexGenParameteriSGIS( GLenum, GLint )
    maxParam = 2;
    READ_ENUM_PARAM(0);
    READ_PARAM(v32bit,1);
    TR.skipLine();
    CHECK_USER_CALL(glPixelTexGenParameteriSGIS)
        UCT.glPixelTexGenParameteriSGIS(param[0].uv32bit, param[1].v32bit);
    CHECK_GL_CALL(glPixelTexGenParameteriSGIS)
        JT.glPixelTexGenParameteriSGIS(param[0].uv32bit, param[1].v32bit);
}

void STUB_glPixelTexGenParameterivSGIS( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glPixelTexGenParameterivSGIS( GLenum, const GLint * )
    maxParam = 2;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ARRAY_PARAM( 1, buffer0, TraceReader::TEXT_INT);
    TR.skipLine();
    CHECK_USER_CALL(glPixelTexGenParameterivSGIS)
        UCT.glPixelTexGenParameterivSGIS(param[0].uv32bit, (const GLint *)param[1].ptr);
    CHECK_GL_CALL(glPixelTexGenParameterivSGIS)
        JT.glPixelTexGenParameterivSGIS(param[0].uv32bit, (const GLint *)param[1].ptr);
}

void STUB_glPixelTexGenSGIX( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glPixelTexGenSGIX( GLenum )
    maxParam = 1;
    READ_ENUM_PARAM(0);
    TR.skipLine();
    CHECK_USER_CALL(glPixelTexGenSGIX)
        UCT.glPixelTexGenSGIX(param[0].uv32bit);
    CHECK_GL_CALL(glPixelTexGenSGIX)
        JT.glPixelTexGenSGIX(param[0].uv32bit);
}

void STUB_glPixelTransferf( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glPixelTransferf( GLenum pname, GLfloat param )
    maxParam = 2;
    READ_ENUM_PARAM(0);
    READ_PARAM(fv32bit,1);
    TR.skipLine();
    CHECK_USER_CALL(glPixelTransferf)
        UCT.glPixelTransferf(param[0].uv32bit, param[1].fv32bit);
    CHECK_GL_CALL(glPixelTransferf)
        JT.glPixelTransferf(param[0].uv32bit, param[1].fv32bit);
}

void STUB_glPixelTransferi( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glPixelTransferi( GLenum pname, GLint param )
    maxParam = 2;
    READ_ENUM_PARAM(0);
    READ_PARAM(v32bit,1);
    TR.skipLine();
    CHECK_USER_CALL(glPixelTransferi)
        UCT.glPixelTransferi(param[0].uv32bit, param[1].v32bit);
    CHECK_GL_CALL(glPixelTransferi)
        JT.glPixelTransferi(param[0].uv32bit, param[1].v32bit);
}

void STUB_glPixelTransformParameterfEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glPixelTransformParameterfEXT( GLenum, GLenum, GLfloat )
    maxParam = 3;
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_PARAM(fv32bit,2);
    TR.skipLine();
    CHECK_USER_CALL(glPixelTransformParameterfEXT)
        UCT.glPixelTransformParameterfEXT(param[0].uv32bit, param[1].uv32bit, param[2].fv32bit);
    CHECK_GL_CALL(glPixelTransformParameterfEXT)
        JT.glPixelTransformParameterfEXT(param[0].uv32bit, param[1].uv32bit, param[2].fv32bit);
}

void STUB_glPixelTransformParameterfvEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glPixelTransformParameterfvEXT( GLenum, GLenum, const GLfloat * )
    maxParam = 3;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_ARRAY_PARAM( 2, buffer0, TraceReader::TEXT_FLOAT);
    TR.skipLine();
    CHECK_USER_CALL(glPixelTransformParameterfvEXT)
        UCT.glPixelTransformParameterfvEXT(param[0].uv32bit, param[1].uv32bit, (const GLfloat *)param[2].ptr);
    CHECK_GL_CALL(glPixelTransformParameterfvEXT)
        JT.glPixelTransformParameterfvEXT(param[0].uv32bit, param[1].uv32bit, (const GLfloat *)param[2].ptr);
}

void STUB_glPixelTransformParameteriEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glPixelTransformParameteriEXT( GLenum, GLenum, GLint )
    maxParam = 3;
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_PARAM(v32bit,2);
    TR.skipLine();
    CHECK_USER_CALL(glPixelTransformParameteriEXT)
        UCT.glPixelTransformParameteriEXT(param[0].uv32bit, param[1].uv32bit, param[2].v32bit);
    CHECK_GL_CALL(glPixelTransformParameteriEXT)
        JT.glPixelTransformParameteriEXT(param[0].uv32bit, param[1].uv32bit, param[2].v32bit);
}

void STUB_glPixelTransformParameterivEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glPixelTransformParameterivEXT( GLenum, GLenum, const GLint * )
    maxParam = 3;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_ARRAY_PARAM( 2, buffer0, TraceReader::TEXT_INT);
    TR.skipLine();
    CHECK_USER_CALL(glPixelTransformParameterivEXT)
        UCT.glPixelTransformParameterivEXT(param[0].uv32bit, param[1].uv32bit, (const GLint *)param[2].ptr);
    CHECK_GL_CALL(glPixelTransformParameterivEXT)
        JT.glPixelTransformParameterivEXT(param[0].uv32bit, param[1].uv32bit, (const GLint *)param[2].ptr);
}

void STUB_glPixelZoom( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glPixelZoom( GLfloat xfactor, GLfloat yfactor )
    maxParam = 2;
    READ_PARAM(fv32bit,0);
    READ_PARAM(fv32bit,1);
    TR.skipLine();
    CHECK_USER_CALL(glPixelZoom)
        UCT.glPixelZoom(param[0].fv32bit, param[1].fv32bit);
    CHECK_GL_CALL(glPixelZoom)
        JT.glPixelZoom(param[0].fv32bit, param[1].fv32bit);
}

void STUB_glPointParameterf( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glPointParameterf( GLenum, GLfloat )
    maxParam = 2;
    READ_ENUM_PARAM(0);
    READ_PARAM(fv32bit,1);
    TR.skipLine();
    CHECK_USER_CALL(glPointParameterf)
        UCT.glPointParameterf(param[0].uv32bit, param[1].fv32bit);
    CHECK_GL_CALL(glPointParameterf)
        JT.glPointParameterf(param[0].uv32bit, param[1].fv32bit);
}

void STUB_glPointParameterfARB( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glPointParameterfARB( GLenum, GLfloat )
    maxParam = 2;
    READ_ENUM_PARAM(0);
    READ_PARAM(fv32bit,1);
    TR.skipLine();
    CHECK_USER_CALL(glPointParameterfARB)
        UCT.glPointParameterfARB(param[0].uv32bit, param[1].fv32bit);
    CHECK_GL_CALL(glPointParameterfARB)
        JT.glPointParameterfARB(param[0].uv32bit, param[1].fv32bit);
}

void STUB_glPointParameterfEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glPointParameterfEXT( GLenum, GLfloat )
    maxParam = 2;
    READ_ENUM_PARAM(0);
    READ_PARAM(fv32bit,1);
    TR.skipLine();
    CHECK_USER_CALL(glPointParameterfEXT)
        UCT.glPointParameterfEXT(param[0].uv32bit, param[1].fv32bit);
    CHECK_GL_CALL(glPointParameterfEXT)
        JT.glPointParameterfEXT(param[0].uv32bit, param[1].fv32bit);
}

void STUB_glPointParameterfSGIS( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glPointParameterfSGIS( GLenum, GLfloat )
    maxParam = 2;
    READ_ENUM_PARAM(0);
    READ_PARAM(fv32bit,1);
    TR.skipLine();
    CHECK_USER_CALL(glPointParameterfSGIS)
        UCT.glPointParameterfSGIS(param[0].uv32bit, param[1].fv32bit);
    CHECK_GL_CALL(glPointParameterfSGIS)
        JT.glPointParameterfSGIS(param[0].uv32bit, param[1].fv32bit);
}

void STUB_glPointParameterfv( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glPointParameterfv( GLenum, const GLfloat * )
    maxParam = 2;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ARRAY_PARAM( 1, buffer0, TraceReader::TEXT_FLOAT);
    TR.skipLine();
    CHECK_USER_CALL(glPointParameterfv)
        UCT.glPointParameterfv(param[0].uv32bit, (const GLfloat *)param[1].ptr);
    CHECK_GL_CALL(glPointParameterfv)
        JT.glPointParameterfv(param[0].uv32bit, (const GLfloat *)param[1].ptr);
}

void STUB_glPointParameterfvARB( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glPointParameterfvARB( GLenum, const GLfloat * )
    maxParam = 2;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ARRAY_PARAM( 1, buffer0, TraceReader::TEXT_FLOAT);
    TR.skipLine();
    CHECK_USER_CALL(glPointParameterfvARB)
        UCT.glPointParameterfvARB(param[0].uv32bit, (const GLfloat *)param[1].ptr);
    CHECK_GL_CALL(glPointParameterfvARB)
        JT.glPointParameterfvARB(param[0].uv32bit, (const GLfloat *)param[1].ptr);
}

void STUB_glPointParameterfvEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glPointParameterfvEXT( GLenum, const GLfloat * )
    maxParam = 2;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ARRAY_PARAM( 1, buffer0, TraceReader::TEXT_FLOAT);
    TR.skipLine();
    CHECK_USER_CALL(glPointParameterfvEXT)
        UCT.glPointParameterfvEXT(param[0].uv32bit, (const GLfloat *)param[1].ptr);
    CHECK_GL_CALL(glPointParameterfvEXT)
        JT.glPointParameterfvEXT(param[0].uv32bit, (const GLfloat *)param[1].ptr);
}

void STUB_glPointParameterfvSGIS( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glPointParameterfvSGIS( GLenum, const GLfloat * )
    maxParam = 2;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ARRAY_PARAM( 1, buffer0, TraceReader::TEXT_FLOAT);
    TR.skipLine();
    CHECK_USER_CALL(glPointParameterfvSGIS)
        UCT.glPointParameterfvSGIS(param[0].uv32bit, (const GLfloat *)param[1].ptr);
    CHECK_GL_CALL(glPointParameterfvSGIS)
        JT.glPointParameterfvSGIS(param[0].uv32bit, (const GLfloat *)param[1].ptr);
}

void STUB_glPointParameteri( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glPointParameteri( GLenum, GLint )
    maxParam = 2;
    READ_ENUM_PARAM(0);
    READ_PARAM(v32bit,1);
    TR.skipLine();
    CHECK_USER_CALL(glPointParameteri)
        UCT.glPointParameteri(param[0].uv32bit, param[1].v32bit);
    CHECK_GL_CALL(glPointParameteri)
        JT.glPointParameteri(param[0].uv32bit, param[1].v32bit);
}

void STUB_glPointParameteriNV( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glPointParameteriNV( GLenum, GLint )
    maxParam = 2;
    READ_ENUM_PARAM(0);
    READ_PARAM(v32bit,1);
    TR.skipLine();
    CHECK_USER_CALL(glPointParameteriNV)
        UCT.glPointParameteriNV(param[0].uv32bit, param[1].v32bit);
    CHECK_GL_CALL(glPointParameteriNV)
        JT.glPointParameteriNV(param[0].uv32bit, param[1].v32bit);
}

void STUB_glPointParameteriv( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glPointParameteriv( GLenum, const GLint * )
    maxParam = 2;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ARRAY_PARAM( 1, buffer0, TraceReader::TEXT_INT);
    TR.skipLine();
    CHECK_USER_CALL(glPointParameteriv)
        UCT.glPointParameteriv(param[0].uv32bit, (const GLint *)param[1].ptr);
    CHECK_GL_CALL(glPointParameteriv)
        JT.glPointParameteriv(param[0].uv32bit, (const GLint *)param[1].ptr);
}

void STUB_glPointParameterivNV( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glPointParameterivNV( GLenum, const GLint * )
    maxParam = 2;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ARRAY_PARAM( 1, buffer0, TraceReader::TEXT_INT);
    TR.skipLine();
    CHECK_USER_CALL(glPointParameterivNV)
        UCT.glPointParameterivNV(param[0].uv32bit, (const GLint *)param[1].ptr);
    CHECK_GL_CALL(glPointParameterivNV)
        JT.glPointParameterivNV(param[0].uv32bit, (const GLint *)param[1].ptr);
}

void STUB_glPointSize( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glPointSize( GLfloat size )
    maxParam = 1;
    READ_PARAM(fv32bit,0);
    TR.skipLine();
    CHECK_USER_CALL(glPointSize)
        UCT.glPointSize(param[0].fv32bit);
    CHECK_GL_CALL(glPointSize)
        JT.glPointSize(param[0].fv32bit);
}

void STUB_glPollAsyncSGIX( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // GLint glPollAsyncSGIX( GLuint * )
    maxParam = 1;
    char buffer0[16*4096];
    READ_ARRAY_PARAM( 0, buffer0, TraceReader::TEXT_INT);
    TR.skipResult();
    TR.skipLine();
    CHECK_USER_CALL(glPollAsyncSGIX)
        UCT.glPollAsyncSGIX((GLuint *)param[0].ptr);
    CHECK_GL_CALL(glPollAsyncSGIX)
        JT.glPollAsyncSGIX((GLuint *)param[0].ptr);
}

void STUB_glPollInstrumentsSGIX( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // GLint glPollInstrumentsSGIX( GLint * )
    maxParam = 1;
    char buffer0[16*4096];
    READ_ARRAY_PARAM( 0, buffer0, TraceReader::TEXT_INT);
    TR.skipResult();
    TR.skipLine();
    CHECK_USER_CALL(glPollInstrumentsSGIX)
        UCT.glPollInstrumentsSGIX((GLint *)param[0].ptr);
    CHECK_GL_CALL(glPollInstrumentsSGIX)
        JT.glPollInstrumentsSGIX((GLint *)param[0].ptr);
}

void STUB_glPolygonMode( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glPolygonMode( GLenum face, GLenum mode )
    maxParam = 2;
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    TR.skipLine();
    CHECK_USER_CALL(glPolygonMode)
        UCT.glPolygonMode(param[0].uv32bit, param[1].uv32bit);
    CHECK_GL_CALL(glPolygonMode)
        JT.glPolygonMode(param[0].uv32bit, param[1].uv32bit);
}

void STUB_glPolygonOffset( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glPolygonOffset( GLfloat factor, GLfloat units )
    maxParam = 2;
    READ_PARAM(fv32bit,0);
    READ_PARAM(fv32bit,1);
    TR.skipLine();
    CHECK_USER_CALL(glPolygonOffset)
        UCT.glPolygonOffset(param[0].fv32bit, param[1].fv32bit);
    CHECK_GL_CALL(glPolygonOffset)
        JT.glPolygonOffset(param[0].fv32bit, param[1].fv32bit);
}

void STUB_glPolygonOffsetEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glPolygonOffsetEXT( GLfloat, GLfloat )
    maxParam = 2;
    READ_PARAM(fv32bit,0);
    READ_PARAM(fv32bit,1);
    TR.skipLine();
    CHECK_USER_CALL(glPolygonOffsetEXT)
        UCT.glPolygonOffsetEXT(param[0].fv32bit, param[1].fv32bit);
    CHECK_GL_CALL(glPolygonOffsetEXT)
        JT.glPolygonOffsetEXT(param[0].fv32bit, param[1].fv32bit);
}

void STUB_glPolygonStipple( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glPolygonStipple( const GLubyte *mask )
    maxParam = 1;
    char buffer0[16*4096];
    READ_ARRAY_PARAM( 0, buffer0, TraceReader::TEXT_BYTE);
    TR.skipLine();
    CHECK_USER_CALL(glPolygonStipple)
        UCT.glPolygonStipple((const GLubyte *)param[0].ptr);
    CHECK_GL_CALL(glPolygonStipple)
        JT.glPolygonStipple((const GLubyte *)param[0].ptr);
}

void STUB_glPopAttrib( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glPopAttrib(  )
    maxParam = 0;
    TR.skipLine();
    CHECK_USER_CALL(glPopAttrib)
        UCT.glPopAttrib();
    CHECK_GL_CALL(glPopAttrib)
        JT.glPopAttrib();
}

void STUB_glPopClientAttrib( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glPopClientAttrib(  )
    maxParam = 0;
    TR.skipLine();
    CHECK_USER_CALL(glPopClientAttrib)
        UCT.glPopClientAttrib();
    CHECK_GL_CALL(glPopClientAttrib)
        JT.glPopClientAttrib();
}

void STUB_glPopMatrix( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glPopMatrix(  )
    maxParam = 0;
    TR.skipLine();
    CHECK_USER_CALL(glPopMatrix)
        UCT.glPopMatrix();
    CHECK_GL_CALL(glPopMatrix)
        JT.glPopMatrix();
}

void STUB_glPopName( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glPopName(  )
    maxParam = 0;
    TR.skipLine();
    CHECK_USER_CALL(glPopName)
        UCT.glPopName();
    CHECK_GL_CALL(glPopName)
        JT.glPopName();
}

void STUB_glPresentFrameDualFillNV( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glPresentFrameDualFillNV( GLuint, GLuint64EXT, GLuint, GLuint, GLenum, GLenum, GLuint, GLenum, GLuint, GLenum, GLuint, GLenum, GLuint )
    // Call not playable
    TR.skipCall();
}

void STUB_glPresentFrameKeyedNV( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glPresentFrameKeyedNV( GLuint, GLuint64EXT, GLuint, GLuint, GLenum, GLenum, GLuint, GLuint, GLenum, GLuint, GLuint )
    // Call not playable
    TR.skipCall();
}

void STUB_glPrimitiveRestartIndex( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glPrimitiveRestartIndex( GLuint )
    maxParam = 1;
    READ_ENUM_PARAM(0);
    TR.skipLine();
    CHECK_USER_CALL(glPrimitiveRestartIndex)
        UCT.glPrimitiveRestartIndex(param[0].uv32bit);
    CHECK_GL_CALL(glPrimitiveRestartIndex)
        JT.glPrimitiveRestartIndex(param[0].uv32bit);
}

void STUB_glPrimitiveRestartIndexNV( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glPrimitiveRestartIndexNV( GLuint )
    maxParam = 1;
    READ_ENUM_PARAM(0);
    TR.skipLine();
    CHECK_USER_CALL(glPrimitiveRestartIndexNV)
        UCT.glPrimitiveRestartIndexNV(param[0].uv32bit);
    CHECK_GL_CALL(glPrimitiveRestartIndexNV)
        JT.glPrimitiveRestartIndexNV(param[0].uv32bit);
}

void STUB_glPrimitiveRestartNV( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glPrimitiveRestartNV(  )
    maxParam = 0;
    TR.skipLine();
    CHECK_USER_CALL(glPrimitiveRestartNV)
        UCT.glPrimitiveRestartNV();
    CHECK_GL_CALL(glPrimitiveRestartNV)
        JT.glPrimitiveRestartNV();
}

void STUB_glPrioritizeTextures( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glPrioritizeTextures( GLsizei n, const GLuint *textures, const GLclampf *priorities )
    maxParam = 3;
    char buffer0[16*4096];
    char buffer1[16*4096];
    READ_PARAM(v32bit,0);
    READ_ARRAY_PARAM( 1, buffer0, TraceReader::TEXT_INT);
    READ_ARRAY_PARAM( 2, buffer1, TraceReader::TEXT_FLOAT);
    TR.skipLine();
    CHECK_USER_CALL(glPrioritizeTextures)
        UCT.glPrioritizeTextures(param[0].v32bit, (const GLuint *)param[1].ptr, (const GLclampf *)param[2].ptr);
    CHECK_GL_CALL(glPrioritizeTextures)
        JT.glPrioritizeTextures(param[0].v32bit, (const GLuint *)param[1].ptr, (const GLclampf *)param[2].ptr);
}

void STUB_glPrioritizeTexturesEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glPrioritizeTexturesEXT( GLsizei, const GLuint *, const GLclampf * )
    maxParam = 3;
    char buffer0[16*4096];
    char buffer1[16*4096];
    READ_PARAM(v32bit,0);
    READ_ARRAY_PARAM( 1, buffer0, TraceReader::TEXT_INT);
    READ_ARRAY_PARAM( 2, buffer1, TraceReader::TEXT_FLOAT);
    TR.skipLine();
    CHECK_USER_CALL(glPrioritizeTexturesEXT)
        UCT.glPrioritizeTexturesEXT(param[0].v32bit, (const GLuint *)param[1].ptr, (const GLclampf *)param[2].ptr);
    CHECK_GL_CALL(glPrioritizeTexturesEXT)
        JT.glPrioritizeTexturesEXT(param[0].v32bit, (const GLuint *)param[1].ptr, (const GLclampf *)param[2].ptr);
}

void STUB_glProgramBufferParametersIivNV( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glProgramBufferParametersIivNV( GLenum, GLuint, GLuint, GLsizei, const GLint * )
    maxParam = 5;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_ENUM_PARAM(2);
    READ_PARAM(v32bit,3);
    READ_ARRAY_PARAM( 4, buffer0, TraceReader::TEXT_INT);
    TR.skipLine();
    CHECK_USER_CALL(glProgramBufferParametersIivNV)
        UCT.glProgramBufferParametersIivNV(param[0].uv32bit, param[1].uv32bit, param[2].uv32bit, param[3].v32bit, (const GLint *)param[4].ptr);
    CHECK_GL_CALL(glProgramBufferParametersIivNV)
        JT.glProgramBufferParametersIivNV(param[0].uv32bit, param[1].uv32bit, param[2].uv32bit, param[3].v32bit, (const GLint *)param[4].ptr);
}

void STUB_glProgramBufferParametersIuivNV( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glProgramBufferParametersIuivNV( GLenum, GLuint, GLuint, GLsizei, const GLuint * )
    maxParam = 5;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_ENUM_PARAM(2);
    READ_PARAM(v32bit,3);
    READ_ARRAY_PARAM( 4, buffer0, TraceReader::TEXT_INT);
    TR.skipLine();
    CHECK_USER_CALL(glProgramBufferParametersIuivNV)
        UCT.glProgramBufferParametersIuivNV(param[0].uv32bit, param[1].uv32bit, param[2].uv32bit, param[3].v32bit, (const GLuint *)param[4].ptr);
    CHECK_GL_CALL(glProgramBufferParametersIuivNV)
        JT.glProgramBufferParametersIuivNV(param[0].uv32bit, param[1].uv32bit, param[2].uv32bit, param[3].v32bit, (const GLuint *)param[4].ptr);
}

void STUB_glProgramBufferParametersfvNV( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glProgramBufferParametersfvNV( GLenum, GLuint, GLuint, GLsizei, const GLfloat * )
    maxParam = 5;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_ENUM_PARAM(2);
    READ_PARAM(v32bit,3);
    READ_ARRAY_PARAM( 4, buffer0, TraceReader::TEXT_FLOAT);
    TR.skipLine();
    CHECK_USER_CALL(glProgramBufferParametersfvNV)
        UCT.glProgramBufferParametersfvNV(param[0].uv32bit, param[1].uv32bit, param[2].uv32bit, param[3].v32bit, (const GLfloat *)param[4].ptr);
    CHECK_GL_CALL(glProgramBufferParametersfvNV)
        JT.glProgramBufferParametersfvNV(param[0].uv32bit, param[1].uv32bit, param[2].uv32bit, param[3].v32bit, (const GLfloat *)param[4].ptr);
}

void STUB_glProgramEnvParameter4dARB( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glProgramEnvParameter4dARB( GLenum, GLuint, GLdouble, GLdouble, GLdouble, GLdouble )
    maxParam = 6;
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_DOUBLE_PARAM(2);
    READ_DOUBLE_PARAM(3);
    READ_DOUBLE_PARAM(4);
    READ_DOUBLE_PARAM(5);
    TR.skipLine();
    CHECK_USER_CALL(glProgramEnvParameter4dARB)
        UCT.glProgramEnvParameter4dARB(param[0].uv32bit, param[1].uv32bit, param[2].fv64bit, param[3].fv64bit, param[4].fv64bit, param[5].fv64bit);
    CHECK_GL_CALL(glProgramEnvParameter4dARB)
        JT.glProgramEnvParameter4dARB(param[0].uv32bit, param[1].uv32bit, param[2].fv64bit, param[3].fv64bit, param[4].fv64bit, param[5].fv64bit);
}

void STUB_glProgramEnvParameter4dvARB( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glProgramEnvParameter4dvARB( GLenum, GLuint, const GLdouble * )
    maxParam = 3;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_ARRAY_PARAM( 2, buffer0, TraceReader::TEXT_DOUBLE);
    TR.skipLine();
    CHECK_USER_CALL(glProgramEnvParameter4dvARB)
        UCT.glProgramEnvParameter4dvARB(param[0].uv32bit, param[1].uv32bit, (const GLdouble *)param[2].ptr);
    CHECK_GL_CALL(glProgramEnvParameter4dvARB)
        JT.glProgramEnvParameter4dvARB(param[0].uv32bit, param[1].uv32bit, (const GLdouble *)param[2].ptr);
}

void STUB_glProgramEnvParameter4fARB( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glProgramEnvParameter4fARB( GLenum, GLuint, GLfloat, GLfloat, GLfloat, GLfloat )
    maxParam = 6;
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_PARAM(fv32bit,2);
    READ_PARAM(fv32bit,3);
    READ_PARAM(fv32bit,4);
    READ_PARAM(fv32bit,5);
    TR.skipLine();
    CHECK_USER_CALL(glProgramEnvParameter4fARB)
        UCT.glProgramEnvParameter4fARB(param[0].uv32bit, param[1].uv32bit, param[2].fv32bit, param[3].fv32bit, param[4].fv32bit, param[5].fv32bit);
    CHECK_GL_CALL(glProgramEnvParameter4fARB)
        JT.glProgramEnvParameter4fARB(param[0].uv32bit, param[1].uv32bit, param[2].fv32bit, param[3].fv32bit, param[4].fv32bit, param[5].fv32bit);
}

void STUB_glProgramEnvParameter4fvARB( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glProgramEnvParameter4fvARB( GLenum, GLuint, const GLfloat * )
    maxParam = 3;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_ARRAY_PARAM( 2, buffer0, TraceReader::TEXT_FLOAT);
    TR.skipLine();
    CHECK_USER_CALL(glProgramEnvParameter4fvARB)
        UCT.glProgramEnvParameter4fvARB(param[0].uv32bit, param[1].uv32bit, (const GLfloat *)param[2].ptr);
    CHECK_GL_CALL(glProgramEnvParameter4fvARB)
        JT.glProgramEnvParameter4fvARB(param[0].uv32bit, param[1].uv32bit, (const GLfloat *)param[2].ptr);
}

void STUB_glProgramEnvParameterI4iNV( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glProgramEnvParameterI4iNV( GLenum, GLuint, GLint, GLint, GLint, GLint )
    maxParam = 6;
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_PARAM(v32bit,2);
    READ_PARAM(v32bit,3);
    READ_PARAM(v32bit,4);
    READ_PARAM(v32bit,5);
    TR.skipLine();
    CHECK_USER_CALL(glProgramEnvParameterI4iNV)
        UCT.glProgramEnvParameterI4iNV(param[0].uv32bit, param[1].uv32bit, param[2].v32bit, param[3].v32bit, param[4].v32bit, param[5].v32bit);
    CHECK_GL_CALL(glProgramEnvParameterI4iNV)
        JT.glProgramEnvParameterI4iNV(param[0].uv32bit, param[1].uv32bit, param[2].v32bit, param[3].v32bit, param[4].v32bit, param[5].v32bit);
}

void STUB_glProgramEnvParameterI4ivNV( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glProgramEnvParameterI4ivNV( GLenum, GLuint, const GLint * )
    maxParam = 3;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_ARRAY_PARAM( 2, buffer0, TraceReader::TEXT_INT);
    TR.skipLine();
    CHECK_USER_CALL(glProgramEnvParameterI4ivNV)
        UCT.glProgramEnvParameterI4ivNV(param[0].uv32bit, param[1].uv32bit, (const GLint *)param[2].ptr);
    CHECK_GL_CALL(glProgramEnvParameterI4ivNV)
        JT.glProgramEnvParameterI4ivNV(param[0].uv32bit, param[1].uv32bit, (const GLint *)param[2].ptr);
}

void STUB_glProgramEnvParameterI4uiNV( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glProgramEnvParameterI4uiNV( GLenum, GLuint, GLuint, GLuint, GLuint, GLuint )
    maxParam = 6;
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_ENUM_PARAM(2);
    READ_ENUM_PARAM(3);
    READ_ENUM_PARAM(4);
    READ_ENUM_PARAM(5);
    TR.skipLine();
    CHECK_USER_CALL(glProgramEnvParameterI4uiNV)
        UCT.glProgramEnvParameterI4uiNV(param[0].uv32bit, param[1].uv32bit, param[2].uv32bit, param[3].uv32bit, param[4].uv32bit, param[5].uv32bit);
    CHECK_GL_CALL(glProgramEnvParameterI4uiNV)
        JT.glProgramEnvParameterI4uiNV(param[0].uv32bit, param[1].uv32bit, param[2].uv32bit, param[3].uv32bit, param[4].uv32bit, param[5].uv32bit);
}

void STUB_glProgramEnvParameterI4uivNV( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glProgramEnvParameterI4uivNV( GLenum, GLuint, const GLuint * )
    maxParam = 3;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_ARRAY_PARAM( 2, buffer0, TraceReader::TEXT_INT);
    TR.skipLine();
    CHECK_USER_CALL(glProgramEnvParameterI4uivNV)
        UCT.glProgramEnvParameterI4uivNV(param[0].uv32bit, param[1].uv32bit, (const GLuint *)param[2].ptr);
    CHECK_GL_CALL(glProgramEnvParameterI4uivNV)
        JT.glProgramEnvParameterI4uivNV(param[0].uv32bit, param[1].uv32bit, (const GLuint *)param[2].ptr);
}

void STUB_glProgramEnvParameters4fvEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glProgramEnvParameters4fvEXT( GLenum, GLuint, GLsizei, const GLfloat * )
    maxParam = 4;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_PARAM(v32bit,2);
    READ_ARRAY_PARAM( 3, buffer0, TraceReader::TEXT_FLOAT);
    TR.skipLine();
    CHECK_USER_CALL(glProgramEnvParameters4fvEXT)
        UCT.glProgramEnvParameters4fvEXT(param[0].uv32bit, param[1].uv32bit, param[2].v32bit, (const GLfloat *)param[3].ptr);
    CHECK_GL_CALL(glProgramEnvParameters4fvEXT)
        JT.glProgramEnvParameters4fvEXT(param[0].uv32bit, param[1].uv32bit, param[2].v32bit, (const GLfloat *)param[3].ptr);
}

void STUB_glProgramEnvParametersI4ivNV( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glProgramEnvParametersI4ivNV( GLenum, GLuint, GLsizei, const GLint * )
    maxParam = 4;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_PARAM(v32bit,2);
    READ_ARRAY_PARAM( 3, buffer0, TraceReader::TEXT_INT);
    TR.skipLine();
    CHECK_USER_CALL(glProgramEnvParametersI4ivNV)
        UCT.glProgramEnvParametersI4ivNV(param[0].uv32bit, param[1].uv32bit, param[2].v32bit, (const GLint *)param[3].ptr);
    CHECK_GL_CALL(glProgramEnvParametersI4ivNV)
        JT.glProgramEnvParametersI4ivNV(param[0].uv32bit, param[1].uv32bit, param[2].v32bit, (const GLint *)param[3].ptr);
}

void STUB_glProgramEnvParametersI4uivNV( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glProgramEnvParametersI4uivNV( GLenum, GLuint, GLsizei, const GLuint * )
    maxParam = 4;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_PARAM(v32bit,2);
    READ_ARRAY_PARAM( 3, buffer0, TraceReader::TEXT_INT);
    TR.skipLine();
    CHECK_USER_CALL(glProgramEnvParametersI4uivNV)
        UCT.glProgramEnvParametersI4uivNV(param[0].uv32bit, param[1].uv32bit, param[2].v32bit, (const GLuint *)param[3].ptr);
    CHECK_GL_CALL(glProgramEnvParametersI4uivNV)
        JT.glProgramEnvParametersI4uivNV(param[0].uv32bit, param[1].uv32bit, param[2].v32bit, (const GLuint *)param[3].ptr);
}

void STUB_glProgramLocalParameter4dARB( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glProgramLocalParameter4dARB( GLenum, GLuint, GLdouble, GLdouble, GLdouble, GLdouble )
    maxParam = 6;
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_DOUBLE_PARAM(2);
    READ_DOUBLE_PARAM(3);
    READ_DOUBLE_PARAM(4);
    READ_DOUBLE_PARAM(5);
    TR.skipLine();
    CHECK_USER_CALL(glProgramLocalParameter4dARB)
        UCT.glProgramLocalParameter4dARB(param[0].uv32bit, param[1].uv32bit, param[2].fv64bit, param[3].fv64bit, param[4].fv64bit, param[5].fv64bit);
    CHECK_GL_CALL(glProgramLocalParameter4dARB)
        JT.glProgramLocalParameter4dARB(param[0].uv32bit, param[1].uv32bit, param[2].fv64bit, param[3].fv64bit, param[4].fv64bit, param[5].fv64bit);
}

void STUB_glProgramLocalParameter4dvARB( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glProgramLocalParameter4dvARB( GLenum, GLuint, const GLdouble * )
    maxParam = 3;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_ARRAY_PARAM( 2, buffer0, TraceReader::TEXT_DOUBLE);
    TR.skipLine();
    CHECK_USER_CALL(glProgramLocalParameter4dvARB)
        UCT.glProgramLocalParameter4dvARB(param[0].uv32bit, param[1].uv32bit, (const GLdouble *)param[2].ptr);
    CHECK_GL_CALL(glProgramLocalParameter4dvARB)
        JT.glProgramLocalParameter4dvARB(param[0].uv32bit, param[1].uv32bit, (const GLdouble *)param[2].ptr);
}

void STUB_glProgramLocalParameter4fARB( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glProgramLocalParameter4fARB( GLenum, GLuint, GLfloat, GLfloat, GLfloat, GLfloat )
    maxParam = 6;
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_PARAM(fv32bit,2);
    READ_PARAM(fv32bit,3);
    READ_PARAM(fv32bit,4);
    READ_PARAM(fv32bit,5);
    TR.skipLine();
    CHECK_USER_CALL(glProgramLocalParameter4fARB)
        UCT.glProgramLocalParameter4fARB(param[0].uv32bit, param[1].uv32bit, param[2].fv32bit, param[3].fv32bit, param[4].fv32bit, param[5].fv32bit);
    CHECK_GL_CALL(glProgramLocalParameter4fARB)
        JT.glProgramLocalParameter4fARB(param[0].uv32bit, param[1].uv32bit, param[2].fv32bit, param[3].fv32bit, param[4].fv32bit, param[5].fv32bit);
}

void STUB_glProgramLocalParameter4fvARB( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glProgramLocalParameter4fvARB( GLenum, GLuint, const GLfloat * )
    maxParam = 3;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_ARRAY_PARAM( 2, buffer0, TraceReader::TEXT_FLOAT);
    TR.skipLine();
    CHECK_USER_CALL(glProgramLocalParameter4fvARB)
        UCT.glProgramLocalParameter4fvARB(param[0].uv32bit, param[1].uv32bit, (const GLfloat *)param[2].ptr);
    CHECK_GL_CALL(glProgramLocalParameter4fvARB)
        JT.glProgramLocalParameter4fvARB(param[0].uv32bit, param[1].uv32bit, (const GLfloat *)param[2].ptr);
}

void STUB_glProgramLocalParameterI4iNV( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glProgramLocalParameterI4iNV( GLenum, GLuint, GLint, GLint, GLint, GLint )
    maxParam = 6;
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_PARAM(v32bit,2);
    READ_PARAM(v32bit,3);
    READ_PARAM(v32bit,4);
    READ_PARAM(v32bit,5);
    TR.skipLine();
    CHECK_USER_CALL(glProgramLocalParameterI4iNV)
        UCT.glProgramLocalParameterI4iNV(param[0].uv32bit, param[1].uv32bit, param[2].v32bit, param[3].v32bit, param[4].v32bit, param[5].v32bit);
    CHECK_GL_CALL(glProgramLocalParameterI4iNV)
        JT.glProgramLocalParameterI4iNV(param[0].uv32bit, param[1].uv32bit, param[2].v32bit, param[3].v32bit, param[4].v32bit, param[5].v32bit);
}

void STUB_glProgramLocalParameterI4ivNV( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glProgramLocalParameterI4ivNV( GLenum, GLuint, const GLint * )
    maxParam = 3;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_ARRAY_PARAM( 2, buffer0, TraceReader::TEXT_INT);
    TR.skipLine();
    CHECK_USER_CALL(glProgramLocalParameterI4ivNV)
        UCT.glProgramLocalParameterI4ivNV(param[0].uv32bit, param[1].uv32bit, (const GLint *)param[2].ptr);
    CHECK_GL_CALL(glProgramLocalParameterI4ivNV)
        JT.glProgramLocalParameterI4ivNV(param[0].uv32bit, param[1].uv32bit, (const GLint *)param[2].ptr);
}

void STUB_glProgramLocalParameterI4uiNV( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glProgramLocalParameterI4uiNV( GLenum, GLuint, GLuint, GLuint, GLuint, GLuint )
    maxParam = 6;
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_ENUM_PARAM(2);
    READ_ENUM_PARAM(3);
    READ_ENUM_PARAM(4);
    READ_ENUM_PARAM(5);
    TR.skipLine();
    CHECK_USER_CALL(glProgramLocalParameterI4uiNV)
        UCT.glProgramLocalParameterI4uiNV(param[0].uv32bit, param[1].uv32bit, param[2].uv32bit, param[3].uv32bit, param[4].uv32bit, param[5].uv32bit);
    CHECK_GL_CALL(glProgramLocalParameterI4uiNV)
        JT.glProgramLocalParameterI4uiNV(param[0].uv32bit, param[1].uv32bit, param[2].uv32bit, param[3].uv32bit, param[4].uv32bit, param[5].uv32bit);
}

void STUB_glProgramLocalParameterI4uivNV( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glProgramLocalParameterI4uivNV( GLenum, GLuint, const GLuint * )
    maxParam = 3;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_ARRAY_PARAM( 2, buffer0, TraceReader::TEXT_INT);
    TR.skipLine();
    CHECK_USER_CALL(glProgramLocalParameterI4uivNV)
        UCT.glProgramLocalParameterI4uivNV(param[0].uv32bit, param[1].uv32bit, (const GLuint *)param[2].ptr);
    CHECK_GL_CALL(glProgramLocalParameterI4uivNV)
        JT.glProgramLocalParameterI4uivNV(param[0].uv32bit, param[1].uv32bit, (const GLuint *)param[2].ptr);
}

void STUB_glProgramLocalParameters4fvEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glProgramLocalParameters4fvEXT( GLenum, GLuint, GLsizei, const GLfloat * )
    maxParam = 4;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_PARAM(v32bit,2);
    READ_ARRAY_PARAM( 3, buffer0, TraceReader::TEXT_FLOAT);
    TR.skipLine();
    CHECK_USER_CALL(glProgramLocalParameters4fvEXT)
        UCT.glProgramLocalParameters4fvEXT(param[0].uv32bit, param[1].uv32bit, param[2].v32bit, (const GLfloat *)param[3].ptr);
    CHECK_GL_CALL(glProgramLocalParameters4fvEXT)
        JT.glProgramLocalParameters4fvEXT(param[0].uv32bit, param[1].uv32bit, param[2].v32bit, (const GLfloat *)param[3].ptr);
}

void STUB_glProgramLocalParametersI4ivNV( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glProgramLocalParametersI4ivNV( GLenum, GLuint, GLsizei, const GLint * )
    maxParam = 4;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_PARAM(v32bit,2);
    READ_ARRAY_PARAM( 3, buffer0, TraceReader::TEXT_INT);
    TR.skipLine();
    CHECK_USER_CALL(glProgramLocalParametersI4ivNV)
        UCT.glProgramLocalParametersI4ivNV(param[0].uv32bit, param[1].uv32bit, param[2].v32bit, (const GLint *)param[3].ptr);
    CHECK_GL_CALL(glProgramLocalParametersI4ivNV)
        JT.glProgramLocalParametersI4ivNV(param[0].uv32bit, param[1].uv32bit, param[2].v32bit, (const GLint *)param[3].ptr);
}

void STUB_glProgramLocalParametersI4uivNV( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glProgramLocalParametersI4uivNV( GLenum, GLuint, GLsizei, const GLuint * )
    maxParam = 4;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_PARAM(v32bit,2);
    READ_ARRAY_PARAM( 3, buffer0, TraceReader::TEXT_INT);
    TR.skipLine();
    CHECK_USER_CALL(glProgramLocalParametersI4uivNV)
        UCT.glProgramLocalParametersI4uivNV(param[0].uv32bit, param[1].uv32bit, param[2].v32bit, (const GLuint *)param[3].ptr);
    CHECK_GL_CALL(glProgramLocalParametersI4uivNV)
        JT.glProgramLocalParametersI4uivNV(param[0].uv32bit, param[1].uv32bit, param[2].v32bit, (const GLuint *)param[3].ptr);
}

void STUB_glProgramNamedParameter4dNV( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glProgramNamedParameter4dNV( GLuint, GLsizei, const GLubyte *, GLdouble, GLdouble, GLdouble, GLdouble )
    maxParam = 7;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_PARAM(v32bit,1);
    READ_ARRAY_PARAM( 2, buffer0, TraceReader::TEXT_BYTE);
    READ_DOUBLE_PARAM(3);
    READ_DOUBLE_PARAM(4);
    READ_DOUBLE_PARAM(5);
    READ_DOUBLE_PARAM(6);
    TR.skipLine();
    CHECK_USER_CALL(glProgramNamedParameter4dNV)
        UCT.glProgramNamedParameter4dNV(param[0].uv32bit, param[1].v32bit, (const GLubyte *)param[2].ptr, param[3].fv64bit, param[4].fv64bit, param[5].fv64bit, param[6].fv64bit);
    CHECK_GL_CALL(glProgramNamedParameter4dNV)
        JT.glProgramNamedParameter4dNV(param[0].uv32bit, param[1].v32bit, (const GLubyte *)param[2].ptr, param[3].fv64bit, param[4].fv64bit, param[5].fv64bit, param[6].fv64bit);
}

void STUB_glProgramNamedParameter4dvNV( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glProgramNamedParameter4dvNV( GLuint, GLsizei, const GLubyte *, const GLdouble * )
    maxParam = 4;
    char buffer0[16*4096];
    char buffer1[16*4096];
    READ_ENUM_PARAM(0);
    READ_PARAM(v32bit,1);
    READ_ARRAY_PARAM( 2, buffer0, TraceReader::TEXT_BYTE);
    READ_ARRAY_PARAM( 3, buffer1, TraceReader::TEXT_DOUBLE);
    TR.skipLine();
    CHECK_USER_CALL(glProgramNamedParameter4dvNV)
        UCT.glProgramNamedParameter4dvNV(param[0].uv32bit, param[1].v32bit, (const GLubyte *)param[2].ptr, (const GLdouble *)param[3].ptr);
    CHECK_GL_CALL(glProgramNamedParameter4dvNV)
        JT.glProgramNamedParameter4dvNV(param[0].uv32bit, param[1].v32bit, (const GLubyte *)param[2].ptr, (const GLdouble *)param[3].ptr);
}

void STUB_glProgramNamedParameter4fNV( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glProgramNamedParameter4fNV( GLuint, GLsizei, const GLubyte *, GLfloat, GLfloat, GLfloat, GLfloat )
    maxParam = 7;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_PARAM(v32bit,1);
    READ_ARRAY_PARAM( 2, buffer0, TraceReader::TEXT_BYTE);
    READ_PARAM(fv32bit,3);
    READ_PARAM(fv32bit,4);
    READ_PARAM(fv32bit,5);
    READ_PARAM(fv32bit,6);
    TR.skipLine();
    CHECK_USER_CALL(glProgramNamedParameter4fNV)
        UCT.glProgramNamedParameter4fNV(param[0].uv32bit, param[1].v32bit, (const GLubyte *)param[2].ptr, param[3].fv32bit, param[4].fv32bit, param[5].fv32bit, param[6].fv32bit);
    CHECK_GL_CALL(glProgramNamedParameter4fNV)
        JT.glProgramNamedParameter4fNV(param[0].uv32bit, param[1].v32bit, (const GLubyte *)param[2].ptr, param[3].fv32bit, param[4].fv32bit, param[5].fv32bit, param[6].fv32bit);
}

void STUB_glProgramNamedParameter4fvNV( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glProgramNamedParameter4fvNV( GLuint, GLsizei, const GLubyte *, const GLfloat * )
    maxParam = 4;
    char buffer0[16*4096];
    char buffer1[16*4096];
    READ_ENUM_PARAM(0);
    READ_PARAM(v32bit,1);
    READ_ARRAY_PARAM( 2, buffer0, TraceReader::TEXT_BYTE);
    READ_ARRAY_PARAM( 3, buffer1, TraceReader::TEXT_FLOAT);
    TR.skipLine();
    CHECK_USER_CALL(glProgramNamedParameter4fvNV)
        UCT.glProgramNamedParameter4fvNV(param[0].uv32bit, param[1].v32bit, (const GLubyte *)param[2].ptr, (const GLfloat *)param[3].ptr);
    CHECK_GL_CALL(glProgramNamedParameter4fvNV)
        JT.glProgramNamedParameter4fvNV(param[0].uv32bit, param[1].v32bit, (const GLubyte *)param[2].ptr, (const GLfloat *)param[3].ptr);
}

void STUB_glProgramParameter4dNV( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glProgramParameter4dNV( GLenum, GLuint, GLdouble, GLdouble, GLdouble, GLdouble )
    maxParam = 6;
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_DOUBLE_PARAM(2);
    READ_DOUBLE_PARAM(3);
    READ_DOUBLE_PARAM(4);
    READ_DOUBLE_PARAM(5);
    TR.skipLine();
    CHECK_USER_CALL(glProgramParameter4dNV)
        UCT.glProgramParameter4dNV(param[0].uv32bit, param[1].uv32bit, param[2].fv64bit, param[3].fv64bit, param[4].fv64bit, param[5].fv64bit);
    CHECK_GL_CALL(glProgramParameter4dNV)
        JT.glProgramParameter4dNV(param[0].uv32bit, param[1].uv32bit, param[2].fv64bit, param[3].fv64bit, param[4].fv64bit, param[5].fv64bit);
}

void STUB_glProgramParameter4dvNV( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glProgramParameter4dvNV( GLenum, GLuint, const GLdouble * )
    maxParam = 3;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_ARRAY_PARAM( 2, buffer0, TraceReader::TEXT_DOUBLE);
    TR.skipLine();
    CHECK_USER_CALL(glProgramParameter4dvNV)
        UCT.glProgramParameter4dvNV(param[0].uv32bit, param[1].uv32bit, (const GLdouble *)param[2].ptr);
    CHECK_GL_CALL(glProgramParameter4dvNV)
        JT.glProgramParameter4dvNV(param[0].uv32bit, param[1].uv32bit, (const GLdouble *)param[2].ptr);
}

void STUB_glProgramParameter4fNV( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glProgramParameter4fNV( GLenum, GLuint, GLfloat, GLfloat, GLfloat, GLfloat )
    maxParam = 6;
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_PARAM(fv32bit,2);
    READ_PARAM(fv32bit,3);
    READ_PARAM(fv32bit,4);
    READ_PARAM(fv32bit,5);
    TR.skipLine();
    CHECK_USER_CALL(glProgramParameter4fNV)
        UCT.glProgramParameter4fNV(param[0].uv32bit, param[1].uv32bit, param[2].fv32bit, param[3].fv32bit, param[4].fv32bit, param[5].fv32bit);
    CHECK_GL_CALL(glProgramParameter4fNV)
        JT.glProgramParameter4fNV(param[0].uv32bit, param[1].uv32bit, param[2].fv32bit, param[3].fv32bit, param[4].fv32bit, param[5].fv32bit);
}

void STUB_glProgramParameter4fvNV( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glProgramParameter4fvNV( GLenum, GLuint, const GLfloat * )
    maxParam = 3;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_ARRAY_PARAM( 2, buffer0, TraceReader::TEXT_FLOAT);
    TR.skipLine();
    CHECK_USER_CALL(glProgramParameter4fvNV)
        UCT.glProgramParameter4fvNV(param[0].uv32bit, param[1].uv32bit, (const GLfloat *)param[2].ptr);
    CHECK_GL_CALL(glProgramParameter4fvNV)
        JT.glProgramParameter4fvNV(param[0].uv32bit, param[1].uv32bit, (const GLfloat *)param[2].ptr);
}

void STUB_glProgramParameteriARB( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glProgramParameteriARB( GLuint, GLenum, GLint )
    maxParam = 3;
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_PARAM(v32bit,2);
    TR.skipLine();
    CHECK_USER_CALL(glProgramParameteriARB)
        UCT.glProgramParameteriARB(param[0].uv32bit, param[1].uv32bit, param[2].v32bit);
    CHECK_GL_CALL(glProgramParameteriARB)
        JT.glProgramParameteriARB(param[0].uv32bit, param[1].uv32bit, param[2].v32bit);
}

void STUB_glProgramParameteriEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glProgramParameteriEXT( GLuint, GLenum, GLint )
    maxParam = 3;
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_PARAM(v32bit,2);
    TR.skipLine();
    CHECK_USER_CALL(glProgramParameteriEXT)
        UCT.glProgramParameteriEXT(param[0].uv32bit, param[1].uv32bit, param[2].v32bit);
    CHECK_GL_CALL(glProgramParameteriEXT)
        JT.glProgramParameteriEXT(param[0].uv32bit, param[1].uv32bit, param[2].v32bit);
}

void STUB_glProgramParameters4dvNV( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glProgramParameters4dvNV( GLenum, GLuint, GLuint, const GLdouble * )
    maxParam = 4;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_ENUM_PARAM(2);
    READ_ARRAY_PARAM( 3, buffer0, TraceReader::TEXT_DOUBLE);
    TR.skipLine();
    CHECK_USER_CALL(glProgramParameters4dvNV)
        UCT.glProgramParameters4dvNV(param[0].uv32bit, param[1].uv32bit, param[2].uv32bit, (const GLdouble *)param[3].ptr);
    CHECK_GL_CALL(glProgramParameters4dvNV)
        JT.glProgramParameters4dvNV(param[0].uv32bit, param[1].uv32bit, param[2].uv32bit, (const GLdouble *)param[3].ptr);
}

void STUB_glProgramParameters4fvNV( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glProgramParameters4fvNV( GLenum, GLuint, GLuint, const GLfloat * )
    maxParam = 4;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_ENUM_PARAM(2);
    READ_ARRAY_PARAM( 3, buffer0, TraceReader::TEXT_FLOAT);
    TR.skipLine();
    CHECK_USER_CALL(glProgramParameters4fvNV)
        UCT.glProgramParameters4fvNV(param[0].uv32bit, param[1].uv32bit, param[2].uv32bit, (const GLfloat *)param[3].ptr);
    CHECK_GL_CALL(glProgramParameters4fvNV)
        JT.glProgramParameters4fvNV(param[0].uv32bit, param[1].uv32bit, param[2].uv32bit, (const GLfloat *)param[3].ptr);
}

void STUB_glProgramStringARB( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glProgramStringARB( GLenum, GLenum, GLsizei, const GLvoid * )
    maxParam = 4;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_PARAM(v32bit,2);
    READ_ARRAY_PARAM( 3, buffer0, TraceReader::TEXT_IGNORE);
    TR.skipLine();
    CHECK_USER_CALL(glProgramStringARB)
        UCT.glProgramStringARB(param[0].uv32bit, param[1].uv32bit, param[2].v32bit, (const GLvoid *)param[3].ptr);
    CHECK_GL_CALL(glProgramStringARB)
        JT.glProgramStringARB(param[0].uv32bit, param[1].uv32bit, param[2].v32bit, (const GLvoid *)param[3].ptr);
}

void STUB_glProgramUniform1fEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glProgramUniform1fEXT( GLuint, GLint, GLfloat )
    maxParam = 3;
    READ_ENUM_PARAM(0);
    READ_PARAM(v32bit,1);
    READ_PARAM(fv32bit,2);
    TR.skipLine();
    CHECK_USER_CALL(glProgramUniform1fEXT)
        UCT.glProgramUniform1fEXT(param[0].uv32bit, param[1].v32bit, param[2].fv32bit);
    CHECK_GL_CALL(glProgramUniform1fEXT)
        JT.glProgramUniform1fEXT(param[0].uv32bit, param[1].v32bit, param[2].fv32bit);
}

void STUB_glProgramUniform1fvEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glProgramUniform1fvEXT( GLuint, GLint, GLsizei, const GLfloat * )
    maxParam = 4;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_PARAM(v32bit,1);
    READ_PARAM(v32bit,2);
    READ_ARRAY_PARAM( 3, buffer0, TraceReader::TEXT_FLOAT);
    TR.skipLine();
    CHECK_USER_CALL(glProgramUniform1fvEXT)
        UCT.glProgramUniform1fvEXT(param[0].uv32bit, param[1].v32bit, param[2].v32bit, (const GLfloat *)param[3].ptr);
    CHECK_GL_CALL(glProgramUniform1fvEXT)
        JT.glProgramUniform1fvEXT(param[0].uv32bit, param[1].v32bit, param[2].v32bit, (const GLfloat *)param[3].ptr);
}

void STUB_glProgramUniform1iEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glProgramUniform1iEXT( GLuint, GLint, GLint )
    maxParam = 3;
    READ_ENUM_PARAM(0);
    READ_PARAM(v32bit,1);
    READ_PARAM(v32bit,2);
    TR.skipLine();
    CHECK_USER_CALL(glProgramUniform1iEXT)
        UCT.glProgramUniform1iEXT(param[0].uv32bit, param[1].v32bit, param[2].v32bit);
    CHECK_GL_CALL(glProgramUniform1iEXT)
        JT.glProgramUniform1iEXT(param[0].uv32bit, param[1].v32bit, param[2].v32bit);
}

void STUB_glProgramUniform1ivEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glProgramUniform1ivEXT( GLuint, GLint, GLsizei, const GLint * )
    maxParam = 4;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_PARAM(v32bit,1);
    READ_PARAM(v32bit,2);
    READ_ARRAY_PARAM( 3, buffer0, TraceReader::TEXT_INT);
    TR.skipLine();
    CHECK_USER_CALL(glProgramUniform1ivEXT)
        UCT.glProgramUniform1ivEXT(param[0].uv32bit, param[1].v32bit, param[2].v32bit, (const GLint *)param[3].ptr);
    CHECK_GL_CALL(glProgramUniform1ivEXT)
        JT.glProgramUniform1ivEXT(param[0].uv32bit, param[1].v32bit, param[2].v32bit, (const GLint *)param[3].ptr);
}

void STUB_glProgramUniform1uiEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glProgramUniform1uiEXT( GLuint, GLint, GLuint )
    maxParam = 3;
    READ_ENUM_PARAM(0);
    READ_PARAM(v32bit,1);
    READ_ENUM_PARAM(2);
    TR.skipLine();
    CHECK_USER_CALL(glProgramUniform1uiEXT)
        UCT.glProgramUniform1uiEXT(param[0].uv32bit, param[1].v32bit, param[2].uv32bit);
    CHECK_GL_CALL(glProgramUniform1uiEXT)
        JT.glProgramUniform1uiEXT(param[0].uv32bit, param[1].v32bit, param[2].uv32bit);
}

void STUB_glProgramUniform1uivEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glProgramUniform1uivEXT( GLuint, GLint, GLsizei, const GLuint * )
    maxParam = 4;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_PARAM(v32bit,1);
    READ_PARAM(v32bit,2);
    READ_ARRAY_PARAM( 3, buffer0, TraceReader::TEXT_INT);
    TR.skipLine();
    CHECK_USER_CALL(glProgramUniform1uivEXT)
        UCT.glProgramUniform1uivEXT(param[0].uv32bit, param[1].v32bit, param[2].v32bit, (const GLuint *)param[3].ptr);
    CHECK_GL_CALL(glProgramUniform1uivEXT)
        JT.glProgramUniform1uivEXT(param[0].uv32bit, param[1].v32bit, param[2].v32bit, (const GLuint *)param[3].ptr);
}

void STUB_glProgramUniform2fEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glProgramUniform2fEXT( GLuint, GLint, GLfloat, GLfloat )
    maxParam = 4;
    READ_ENUM_PARAM(0);
    READ_PARAM(v32bit,1);
    READ_PARAM(fv32bit,2);
    READ_PARAM(fv32bit,3);
    TR.skipLine();
    CHECK_USER_CALL(glProgramUniform2fEXT)
        UCT.glProgramUniform2fEXT(param[0].uv32bit, param[1].v32bit, param[2].fv32bit, param[3].fv32bit);
    CHECK_GL_CALL(glProgramUniform2fEXT)
        JT.glProgramUniform2fEXT(param[0].uv32bit, param[1].v32bit, param[2].fv32bit, param[3].fv32bit);
}

void STUB_glProgramUniform2fvEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glProgramUniform2fvEXT( GLuint, GLint, GLsizei, const GLfloat * )
    maxParam = 4;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_PARAM(v32bit,1);
    READ_PARAM(v32bit,2);
    READ_ARRAY_PARAM( 3, buffer0, TraceReader::TEXT_FLOAT);
    TR.skipLine();
    CHECK_USER_CALL(glProgramUniform2fvEXT)
        UCT.glProgramUniform2fvEXT(param[0].uv32bit, param[1].v32bit, param[2].v32bit, (const GLfloat *)param[3].ptr);
    CHECK_GL_CALL(glProgramUniform2fvEXT)
        JT.glProgramUniform2fvEXT(param[0].uv32bit, param[1].v32bit, param[2].v32bit, (const GLfloat *)param[3].ptr);
}

void STUB_glProgramUniform2iEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glProgramUniform2iEXT( GLuint, GLint, GLint, GLint )
    maxParam = 4;
    READ_ENUM_PARAM(0);
    READ_PARAM(v32bit,1);
    READ_PARAM(v32bit,2);
    READ_PARAM(v32bit,3);
    TR.skipLine();
    CHECK_USER_CALL(glProgramUniform2iEXT)
        UCT.glProgramUniform2iEXT(param[0].uv32bit, param[1].v32bit, param[2].v32bit, param[3].v32bit);
    CHECK_GL_CALL(glProgramUniform2iEXT)
        JT.glProgramUniform2iEXT(param[0].uv32bit, param[1].v32bit, param[2].v32bit, param[3].v32bit);
}

void STUB_glProgramUniform2ivEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glProgramUniform2ivEXT( GLuint, GLint, GLsizei, const GLint * )
    maxParam = 4;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_PARAM(v32bit,1);
    READ_PARAM(v32bit,2);
    READ_ARRAY_PARAM( 3, buffer0, TraceReader::TEXT_INT);
    TR.skipLine();
    CHECK_USER_CALL(glProgramUniform2ivEXT)
        UCT.glProgramUniform2ivEXT(param[0].uv32bit, param[1].v32bit, param[2].v32bit, (const GLint *)param[3].ptr);
    CHECK_GL_CALL(glProgramUniform2ivEXT)
        JT.glProgramUniform2ivEXT(param[0].uv32bit, param[1].v32bit, param[2].v32bit, (const GLint *)param[3].ptr);
}

void STUB_glProgramUniform2uiEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glProgramUniform2uiEXT( GLuint, GLint, GLuint, GLuint )
    maxParam = 4;
    READ_ENUM_PARAM(0);
    READ_PARAM(v32bit,1);
    READ_ENUM_PARAM(2);
    READ_ENUM_PARAM(3);
    TR.skipLine();
    CHECK_USER_CALL(glProgramUniform2uiEXT)
        UCT.glProgramUniform2uiEXT(param[0].uv32bit, param[1].v32bit, param[2].uv32bit, param[3].uv32bit);
    CHECK_GL_CALL(glProgramUniform2uiEXT)
        JT.glProgramUniform2uiEXT(param[0].uv32bit, param[1].v32bit, param[2].uv32bit, param[3].uv32bit);
}

void STUB_glProgramUniform2uivEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glProgramUniform2uivEXT( GLuint, GLint, GLsizei, const GLuint * )
    maxParam = 4;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_PARAM(v32bit,1);
    READ_PARAM(v32bit,2);
    READ_ARRAY_PARAM( 3, buffer0, TraceReader::TEXT_INT);
    TR.skipLine();
    CHECK_USER_CALL(glProgramUniform2uivEXT)
        UCT.glProgramUniform2uivEXT(param[0].uv32bit, param[1].v32bit, param[2].v32bit, (const GLuint *)param[3].ptr);
    CHECK_GL_CALL(glProgramUniform2uivEXT)
        JT.glProgramUniform2uivEXT(param[0].uv32bit, param[1].v32bit, param[2].v32bit, (const GLuint *)param[3].ptr);
}

void STUB_glProgramUniform3fEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glProgramUniform3fEXT( GLuint, GLint, GLfloat, GLfloat, GLfloat )
    maxParam = 5;
    READ_ENUM_PARAM(0);
    READ_PARAM(v32bit,1);
    READ_PARAM(fv32bit,2);
    READ_PARAM(fv32bit,3);
    READ_PARAM(fv32bit,4);
    TR.skipLine();
    CHECK_USER_CALL(glProgramUniform3fEXT)
        UCT.glProgramUniform3fEXT(param[0].uv32bit, param[1].v32bit, param[2].fv32bit, param[3].fv32bit, param[4].fv32bit);
    CHECK_GL_CALL(glProgramUniform3fEXT)
        JT.glProgramUniform3fEXT(param[0].uv32bit, param[1].v32bit, param[2].fv32bit, param[3].fv32bit, param[4].fv32bit);
}

void STUB_glProgramUniform3fvEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glProgramUniform3fvEXT( GLuint, GLint, GLsizei, const GLfloat * )
    maxParam = 4;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_PARAM(v32bit,1);
    READ_PARAM(v32bit,2);
    READ_ARRAY_PARAM( 3, buffer0, TraceReader::TEXT_FLOAT);
    TR.skipLine();
    CHECK_USER_CALL(glProgramUniform3fvEXT)
        UCT.glProgramUniform3fvEXT(param[0].uv32bit, param[1].v32bit, param[2].v32bit, (const GLfloat *)param[3].ptr);
    CHECK_GL_CALL(glProgramUniform3fvEXT)
        JT.glProgramUniform3fvEXT(param[0].uv32bit, param[1].v32bit, param[2].v32bit, (const GLfloat *)param[3].ptr);
}

void STUB_glProgramUniform3iEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glProgramUniform3iEXT( GLuint, GLint, GLint, GLint, GLint )
    maxParam = 5;
    READ_ENUM_PARAM(0);
    READ_PARAM(v32bit,1);
    READ_PARAM(v32bit,2);
    READ_PARAM(v32bit,3);
    READ_PARAM(v32bit,4);
    TR.skipLine();
    CHECK_USER_CALL(glProgramUniform3iEXT)
        UCT.glProgramUniform3iEXT(param[0].uv32bit, param[1].v32bit, param[2].v32bit, param[3].v32bit, param[4].v32bit);
    CHECK_GL_CALL(glProgramUniform3iEXT)
        JT.glProgramUniform3iEXT(param[0].uv32bit, param[1].v32bit, param[2].v32bit, param[3].v32bit, param[4].v32bit);
}

void STUB_glProgramUniform3ivEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glProgramUniform3ivEXT( GLuint, GLint, GLsizei, const GLint * )
    maxParam = 4;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_PARAM(v32bit,1);
    READ_PARAM(v32bit,2);
    READ_ARRAY_PARAM( 3, buffer0, TraceReader::TEXT_INT);
    TR.skipLine();
    CHECK_USER_CALL(glProgramUniform3ivEXT)
        UCT.glProgramUniform3ivEXT(param[0].uv32bit, param[1].v32bit, param[2].v32bit, (const GLint *)param[3].ptr);
    CHECK_GL_CALL(glProgramUniform3ivEXT)
        JT.glProgramUniform3ivEXT(param[0].uv32bit, param[1].v32bit, param[2].v32bit, (const GLint *)param[3].ptr);
}

void STUB_glProgramUniform3uiEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glProgramUniform3uiEXT( GLuint, GLint, GLuint, GLuint, GLuint )
    maxParam = 5;
    READ_ENUM_PARAM(0);
    READ_PARAM(v32bit,1);
    READ_ENUM_PARAM(2);
    READ_ENUM_PARAM(3);
    READ_ENUM_PARAM(4);
    TR.skipLine();
    CHECK_USER_CALL(glProgramUniform3uiEXT)
        UCT.glProgramUniform3uiEXT(param[0].uv32bit, param[1].v32bit, param[2].uv32bit, param[3].uv32bit, param[4].uv32bit);
    CHECK_GL_CALL(glProgramUniform3uiEXT)
        JT.glProgramUniform3uiEXT(param[0].uv32bit, param[1].v32bit, param[2].uv32bit, param[3].uv32bit, param[4].uv32bit);
}

void STUB_glProgramUniform3uivEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glProgramUniform3uivEXT( GLuint, GLint, GLsizei, const GLuint * )
    maxParam = 4;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_PARAM(v32bit,1);
    READ_PARAM(v32bit,2);
    READ_ARRAY_PARAM( 3, buffer0, TraceReader::TEXT_INT);
    TR.skipLine();
    CHECK_USER_CALL(glProgramUniform3uivEXT)
        UCT.glProgramUniform3uivEXT(param[0].uv32bit, param[1].v32bit, param[2].v32bit, (const GLuint *)param[3].ptr);
    CHECK_GL_CALL(glProgramUniform3uivEXT)
        JT.glProgramUniform3uivEXT(param[0].uv32bit, param[1].v32bit, param[2].v32bit, (const GLuint *)param[3].ptr);
}

void STUB_glProgramUniform4fEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glProgramUniform4fEXT( GLuint, GLint, GLfloat, GLfloat, GLfloat, GLfloat )
    maxParam = 6;
    READ_ENUM_PARAM(0);
    READ_PARAM(v32bit,1);
    READ_PARAM(fv32bit,2);
    READ_PARAM(fv32bit,3);
    READ_PARAM(fv32bit,4);
    READ_PARAM(fv32bit,5);
    TR.skipLine();
    CHECK_USER_CALL(glProgramUniform4fEXT)
        UCT.glProgramUniform4fEXT(param[0].uv32bit, param[1].v32bit, param[2].fv32bit, param[3].fv32bit, param[4].fv32bit, param[5].fv32bit);
    CHECK_GL_CALL(glProgramUniform4fEXT)
        JT.glProgramUniform4fEXT(param[0].uv32bit, param[1].v32bit, param[2].fv32bit, param[3].fv32bit, param[4].fv32bit, param[5].fv32bit);
}

void STUB_glProgramUniform4fvEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glProgramUniform4fvEXT( GLuint, GLint, GLsizei, const GLfloat * )
    maxParam = 4;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_PARAM(v32bit,1);
    READ_PARAM(v32bit,2);
    READ_ARRAY_PARAM( 3, buffer0, TraceReader::TEXT_FLOAT);
    TR.skipLine();
    CHECK_USER_CALL(glProgramUniform4fvEXT)
        UCT.glProgramUniform4fvEXT(param[0].uv32bit, param[1].v32bit, param[2].v32bit, (const GLfloat *)param[3].ptr);
    CHECK_GL_CALL(glProgramUniform4fvEXT)
        JT.glProgramUniform4fvEXT(param[0].uv32bit, param[1].v32bit, param[2].v32bit, (const GLfloat *)param[3].ptr);
}

void STUB_glProgramUniform4iEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glProgramUniform4iEXT( GLuint, GLint, GLint, GLint, GLint, GLint )
    maxParam = 6;
    READ_ENUM_PARAM(0);
    READ_PARAM(v32bit,1);
    READ_PARAM(v32bit,2);
    READ_PARAM(v32bit,3);
    READ_PARAM(v32bit,4);
    READ_PARAM(v32bit,5);
    TR.skipLine();
    CHECK_USER_CALL(glProgramUniform4iEXT)
        UCT.glProgramUniform4iEXT(param[0].uv32bit, param[1].v32bit, param[2].v32bit, param[3].v32bit, param[4].v32bit, param[5].v32bit);
    CHECK_GL_CALL(glProgramUniform4iEXT)
        JT.glProgramUniform4iEXT(param[0].uv32bit, param[1].v32bit, param[2].v32bit, param[3].v32bit, param[4].v32bit, param[5].v32bit);
}

void STUB_glProgramUniform4ivEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glProgramUniform4ivEXT( GLuint, GLint, GLsizei, const GLint * )
    maxParam = 4;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_PARAM(v32bit,1);
    READ_PARAM(v32bit,2);
    READ_ARRAY_PARAM( 3, buffer0, TraceReader::TEXT_INT);
    TR.skipLine();
    CHECK_USER_CALL(glProgramUniform4ivEXT)
        UCT.glProgramUniform4ivEXT(param[0].uv32bit, param[1].v32bit, param[2].v32bit, (const GLint *)param[3].ptr);
    CHECK_GL_CALL(glProgramUniform4ivEXT)
        JT.glProgramUniform4ivEXT(param[0].uv32bit, param[1].v32bit, param[2].v32bit, (const GLint *)param[3].ptr);
}

void STUB_glProgramUniform4uiEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glProgramUniform4uiEXT( GLuint, GLint, GLuint, GLuint, GLuint, GLuint )
    maxParam = 6;
    READ_ENUM_PARAM(0);
    READ_PARAM(v32bit,1);
    READ_ENUM_PARAM(2);
    READ_ENUM_PARAM(3);
    READ_ENUM_PARAM(4);
    READ_ENUM_PARAM(5);
    TR.skipLine();
    CHECK_USER_CALL(glProgramUniform4uiEXT)
        UCT.glProgramUniform4uiEXT(param[0].uv32bit, param[1].v32bit, param[2].uv32bit, param[3].uv32bit, param[4].uv32bit, param[5].uv32bit);
    CHECK_GL_CALL(glProgramUniform4uiEXT)
        JT.glProgramUniform4uiEXT(param[0].uv32bit, param[1].v32bit, param[2].uv32bit, param[3].uv32bit, param[4].uv32bit, param[5].uv32bit);
}

void STUB_glProgramUniform4uivEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glProgramUniform4uivEXT( GLuint, GLint, GLsizei, const GLuint * )
    maxParam = 4;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_PARAM(v32bit,1);
    READ_PARAM(v32bit,2);
    READ_ARRAY_PARAM( 3, buffer0, TraceReader::TEXT_INT);
    TR.skipLine();
    CHECK_USER_CALL(glProgramUniform4uivEXT)
        UCT.glProgramUniform4uivEXT(param[0].uv32bit, param[1].v32bit, param[2].v32bit, (const GLuint *)param[3].ptr);
    CHECK_GL_CALL(glProgramUniform4uivEXT)
        JT.glProgramUniform4uivEXT(param[0].uv32bit, param[1].v32bit, param[2].v32bit, (const GLuint *)param[3].ptr);
}

void STUB_glProgramUniformMatrix2fvEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glProgramUniformMatrix2fvEXT( GLuint, GLint, GLsizei, GLboolean, const GLfloat * )
    maxParam = 5;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_PARAM(v32bit,1);
    READ_PARAM(v32bit,2);
    READ_BOOLEAN_PARAM(3);
    READ_ARRAY_PARAM( 4, buffer0, TraceReader::TEXT_FLOAT);
    TR.skipLine();
    CHECK_USER_CALL(glProgramUniformMatrix2fvEXT)
        UCT.glProgramUniformMatrix2fvEXT(param[0].uv32bit, param[1].v32bit, param[2].v32bit, param[3].boolean, (const GLfloat *)param[4].ptr);
    CHECK_GL_CALL(glProgramUniformMatrix2fvEXT)
        JT.glProgramUniformMatrix2fvEXT(param[0].uv32bit, param[1].v32bit, param[2].v32bit, param[3].boolean, (const GLfloat *)param[4].ptr);
}

void STUB_glProgramUniformMatrix2x3fvEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glProgramUniformMatrix2x3fvEXT( GLuint, GLint, GLsizei, GLboolean, const GLfloat * )
    maxParam = 5;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_PARAM(v32bit,1);
    READ_PARAM(v32bit,2);
    READ_BOOLEAN_PARAM(3);
    READ_ARRAY_PARAM( 4, buffer0, TraceReader::TEXT_FLOAT);
    TR.skipLine();
    CHECK_USER_CALL(glProgramUniformMatrix2x3fvEXT)
        UCT.glProgramUniformMatrix2x3fvEXT(param[0].uv32bit, param[1].v32bit, param[2].v32bit, param[3].boolean, (const GLfloat *)param[4].ptr);
    CHECK_GL_CALL(glProgramUniformMatrix2x3fvEXT)
        JT.glProgramUniformMatrix2x3fvEXT(param[0].uv32bit, param[1].v32bit, param[2].v32bit, param[3].boolean, (const GLfloat *)param[4].ptr);
}

void STUB_glProgramUniformMatrix2x4fvEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glProgramUniformMatrix2x4fvEXT( GLuint, GLint, GLsizei, GLboolean, const GLfloat * )
    maxParam = 5;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_PARAM(v32bit,1);
    READ_PARAM(v32bit,2);
    READ_BOOLEAN_PARAM(3);
    READ_ARRAY_PARAM( 4, buffer0, TraceReader::TEXT_FLOAT);
    TR.skipLine();
    CHECK_USER_CALL(glProgramUniformMatrix2x4fvEXT)
        UCT.glProgramUniformMatrix2x4fvEXT(param[0].uv32bit, param[1].v32bit, param[2].v32bit, param[3].boolean, (const GLfloat *)param[4].ptr);
    CHECK_GL_CALL(glProgramUniformMatrix2x4fvEXT)
        JT.glProgramUniformMatrix2x4fvEXT(param[0].uv32bit, param[1].v32bit, param[2].v32bit, param[3].boolean, (const GLfloat *)param[4].ptr);
}

void STUB_glProgramUniformMatrix3fvEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glProgramUniformMatrix3fvEXT( GLuint, GLint, GLsizei, GLboolean, const GLfloat * )
    maxParam = 5;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_PARAM(v32bit,1);
    READ_PARAM(v32bit,2);
    READ_BOOLEAN_PARAM(3);
    READ_ARRAY_PARAM( 4, buffer0, TraceReader::TEXT_FLOAT);
    TR.skipLine();
    CHECK_USER_CALL(glProgramUniformMatrix3fvEXT)
        UCT.glProgramUniformMatrix3fvEXT(param[0].uv32bit, param[1].v32bit, param[2].v32bit, param[3].boolean, (const GLfloat *)param[4].ptr);
    CHECK_GL_CALL(glProgramUniformMatrix3fvEXT)
        JT.glProgramUniformMatrix3fvEXT(param[0].uv32bit, param[1].v32bit, param[2].v32bit, param[3].boolean, (const GLfloat *)param[4].ptr);
}

void STUB_glProgramUniformMatrix3x2fvEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glProgramUniformMatrix3x2fvEXT( GLuint, GLint, GLsizei, GLboolean, const GLfloat * )
    maxParam = 5;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_PARAM(v32bit,1);
    READ_PARAM(v32bit,2);
    READ_BOOLEAN_PARAM(3);
    READ_ARRAY_PARAM( 4, buffer0, TraceReader::TEXT_FLOAT);
    TR.skipLine();
    CHECK_USER_CALL(glProgramUniformMatrix3x2fvEXT)
        UCT.glProgramUniformMatrix3x2fvEXT(param[0].uv32bit, param[1].v32bit, param[2].v32bit, param[3].boolean, (const GLfloat *)param[4].ptr);
    CHECK_GL_CALL(glProgramUniformMatrix3x2fvEXT)
        JT.glProgramUniformMatrix3x2fvEXT(param[0].uv32bit, param[1].v32bit, param[2].v32bit, param[3].boolean, (const GLfloat *)param[4].ptr);
}

void STUB_glProgramUniformMatrix3x4fvEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glProgramUniformMatrix3x4fvEXT( GLuint, GLint, GLsizei, GLboolean, const GLfloat * )
    maxParam = 5;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_PARAM(v32bit,1);
    READ_PARAM(v32bit,2);
    READ_BOOLEAN_PARAM(3);
    READ_ARRAY_PARAM( 4, buffer0, TraceReader::TEXT_FLOAT);
    TR.skipLine();
    CHECK_USER_CALL(glProgramUniformMatrix3x4fvEXT)
        UCT.glProgramUniformMatrix3x4fvEXT(param[0].uv32bit, param[1].v32bit, param[2].v32bit, param[3].boolean, (const GLfloat *)param[4].ptr);
    CHECK_GL_CALL(glProgramUniformMatrix3x4fvEXT)
        JT.glProgramUniformMatrix3x4fvEXT(param[0].uv32bit, param[1].v32bit, param[2].v32bit, param[3].boolean, (const GLfloat *)param[4].ptr);
}

void STUB_glProgramUniformMatrix4fvEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glProgramUniformMatrix4fvEXT( GLuint, GLint, GLsizei, GLboolean, const GLfloat * )
    maxParam = 5;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_PARAM(v32bit,1);
    READ_PARAM(v32bit,2);
    READ_BOOLEAN_PARAM(3);
    READ_ARRAY_PARAM( 4, buffer0, TraceReader::TEXT_FLOAT);
    TR.skipLine();
    CHECK_USER_CALL(glProgramUniformMatrix4fvEXT)
        UCT.glProgramUniformMatrix4fvEXT(param[0].uv32bit, param[1].v32bit, param[2].v32bit, param[3].boolean, (const GLfloat *)param[4].ptr);
    CHECK_GL_CALL(glProgramUniformMatrix4fvEXT)
        JT.glProgramUniformMatrix4fvEXT(param[0].uv32bit, param[1].v32bit, param[2].v32bit, param[3].boolean, (const GLfloat *)param[4].ptr);
}

void STUB_glProgramUniformMatrix4x2fvEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glProgramUniformMatrix4x2fvEXT( GLuint, GLint, GLsizei, GLboolean, const GLfloat * )
    maxParam = 5;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_PARAM(v32bit,1);
    READ_PARAM(v32bit,2);
    READ_BOOLEAN_PARAM(3);
    READ_ARRAY_PARAM( 4, buffer0, TraceReader::TEXT_FLOAT);
    TR.skipLine();
    CHECK_USER_CALL(glProgramUniformMatrix4x2fvEXT)
        UCT.glProgramUniformMatrix4x2fvEXT(param[0].uv32bit, param[1].v32bit, param[2].v32bit, param[3].boolean, (const GLfloat *)param[4].ptr);
    CHECK_GL_CALL(glProgramUniformMatrix4x2fvEXT)
        JT.glProgramUniformMatrix4x2fvEXT(param[0].uv32bit, param[1].v32bit, param[2].v32bit, param[3].boolean, (const GLfloat *)param[4].ptr);
}

void STUB_glProgramUniformMatrix4x3fvEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glProgramUniformMatrix4x3fvEXT( GLuint, GLint, GLsizei, GLboolean, const GLfloat * )
    maxParam = 5;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_PARAM(v32bit,1);
    READ_PARAM(v32bit,2);
    READ_BOOLEAN_PARAM(3);
    READ_ARRAY_PARAM( 4, buffer0, TraceReader::TEXT_FLOAT);
    TR.skipLine();
    CHECK_USER_CALL(glProgramUniformMatrix4x3fvEXT)
        UCT.glProgramUniformMatrix4x3fvEXT(param[0].uv32bit, param[1].v32bit, param[2].v32bit, param[3].boolean, (const GLfloat *)param[4].ptr);
    CHECK_GL_CALL(glProgramUniformMatrix4x3fvEXT)
        JT.glProgramUniformMatrix4x3fvEXT(param[0].uv32bit, param[1].v32bit, param[2].v32bit, param[3].boolean, (const GLfloat *)param[4].ptr);
}

void STUB_glProgramVertexLimitNV( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glProgramVertexLimitNV( GLenum, GLint )
    maxParam = 2;
    READ_ENUM_PARAM(0);
    READ_PARAM(v32bit,1);
    TR.skipLine();
    CHECK_USER_CALL(glProgramVertexLimitNV)
        UCT.glProgramVertexLimitNV(param[0].uv32bit, param[1].v32bit);
    CHECK_GL_CALL(glProgramVertexLimitNV)
        JT.glProgramVertexLimitNV(param[0].uv32bit, param[1].v32bit);
}

void STUB_glProvokingVertexEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glProvokingVertexEXT( GLenum )
    maxParam = 1;
    READ_ENUM_PARAM(0);
    TR.skipLine();
    CHECK_USER_CALL(glProvokingVertexEXT)
        UCT.glProvokingVertexEXT(param[0].uv32bit);
    CHECK_GL_CALL(glProvokingVertexEXT)
        JT.glProvokingVertexEXT(param[0].uv32bit);
}

void STUB_glPushAttrib( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glPushAttrib( GLbitfield mask )
    maxParam = 1;
    READ_ORING_PARAM(0);
    TR.skipLine();
    CHECK_USER_CALL(glPushAttrib)
        UCT.glPushAttrib(param[0].uv32bit);
    CHECK_GL_CALL(glPushAttrib)
        JT.glPushAttrib(param[0].uv32bit);
}

void STUB_glPushClientAttrib( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glPushClientAttrib( GLbitfield mask )
    maxParam = 1;
    READ_ORING_PARAM(0);
    TR.skipLine();
    CHECK_USER_CALL(glPushClientAttrib)
        UCT.glPushClientAttrib(param[0].uv32bit);
    CHECK_GL_CALL(glPushClientAttrib)
        JT.glPushClientAttrib(param[0].uv32bit);
}

void STUB_glPushClientAttribDefaultEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glPushClientAttribDefaultEXT( GLbitfield )
    maxParam = 1;
    READ_ORING_PARAM(0);
    TR.skipLine();
    CHECK_USER_CALL(glPushClientAttribDefaultEXT)
        UCT.glPushClientAttribDefaultEXT(param[0].uv32bit);
    CHECK_GL_CALL(glPushClientAttribDefaultEXT)
        JT.glPushClientAttribDefaultEXT(param[0].uv32bit);
}

void STUB_glPushMatrix( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glPushMatrix(  )
    maxParam = 0;
    TR.skipLine();
    CHECK_USER_CALL(glPushMatrix)
        UCT.glPushMatrix();
    CHECK_GL_CALL(glPushMatrix)
        JT.glPushMatrix();
}

void STUB_glPushName( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glPushName( GLuint name )
    maxParam = 1;
    READ_ENUM_PARAM(0);
    TR.skipLine();
    CHECK_USER_CALL(glPushName)
        UCT.glPushName(param[0].uv32bit);
    CHECK_GL_CALL(glPushName)
        JT.glPushName(param[0].uv32bit);
}

void STUB_glRasterPos2d( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glRasterPos2d( GLdouble x, GLdouble y )
    maxParam = 2;
    READ_DOUBLE_PARAM(0);
    READ_DOUBLE_PARAM(1);
    TR.skipLine();
    CHECK_USER_CALL(glRasterPos2d)
        UCT.glRasterPos2d(param[0].fv64bit, param[1].fv64bit);
    CHECK_GL_CALL(glRasterPos2d)
        JT.glRasterPos2d(param[0].fv64bit, param[1].fv64bit);
}

void STUB_glRasterPos2dv( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glRasterPos2dv( const GLdouble *v )
    maxParam = 1;
    char buffer0[16*4096];
    READ_ARRAY_PARAM( 0, buffer0, TraceReader::TEXT_DOUBLE);
    TR.skipLine();
    CHECK_USER_CALL(glRasterPos2dv)
        UCT.glRasterPos2dv((const GLdouble *)param[0].ptr);
    CHECK_GL_CALL(glRasterPos2dv)
        JT.glRasterPos2dv((const GLdouble *)param[0].ptr);
}

void STUB_glRasterPos2f( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glRasterPos2f( GLfloat x, GLfloat y )
    maxParam = 2;
    READ_PARAM(fv32bit,0);
    READ_PARAM(fv32bit,1);
    TR.skipLine();
    CHECK_USER_CALL(glRasterPos2f)
        UCT.glRasterPos2f(param[0].fv32bit, param[1].fv32bit);
    CHECK_GL_CALL(glRasterPos2f)
        JT.glRasterPos2f(param[0].fv32bit, param[1].fv32bit);
}

void STUB_glRasterPos2fv( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glRasterPos2fv( const GLfloat *v )
    maxParam = 1;
    char buffer0[16*4096];
    READ_ARRAY_PARAM( 0, buffer0, TraceReader::TEXT_FLOAT);
    TR.skipLine();
    CHECK_USER_CALL(glRasterPos2fv)
        UCT.glRasterPos2fv((const GLfloat *)param[0].ptr);
    CHECK_GL_CALL(glRasterPos2fv)
        JT.glRasterPos2fv((const GLfloat *)param[0].ptr);
}

void STUB_glRasterPos2i( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glRasterPos2i( GLint x, GLint y )
    maxParam = 2;
    READ_PARAM(v32bit,0);
    READ_PARAM(v32bit,1);
    TR.skipLine();
    CHECK_USER_CALL(glRasterPos2i)
        UCT.glRasterPos2i(param[0].v32bit, param[1].v32bit);
    CHECK_GL_CALL(glRasterPos2i)
        JT.glRasterPos2i(param[0].v32bit, param[1].v32bit);
}

void STUB_glRasterPos2iv( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glRasterPos2iv( const GLint *v )
    maxParam = 1;
    char buffer0[16*4096];
    READ_ARRAY_PARAM( 0, buffer0, TraceReader::TEXT_INT);
    TR.skipLine();
    CHECK_USER_CALL(glRasterPos2iv)
        UCT.glRasterPos2iv((const GLint *)param[0].ptr);
    CHECK_GL_CALL(glRasterPos2iv)
        JT.glRasterPos2iv((const GLint *)param[0].ptr);
}

void STUB_glRasterPos2s( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glRasterPos2s( GLshort x, GLshort y )
    maxParam = 2;
    READ_PARAM(v16bit,0);
    READ_PARAM(v16bit,1);
    TR.skipLine();
    CHECK_USER_CALL(glRasterPos2s)
        UCT.glRasterPos2s(param[0].v16bit, param[1].v16bit);
    CHECK_GL_CALL(glRasterPos2s)
        JT.glRasterPos2s(param[0].v16bit, param[1].v16bit);
}

void STUB_glRasterPos2sv( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glRasterPos2sv( const GLshort *v )
    maxParam = 1;
    char buffer0[16*4096];
    READ_ARRAY_PARAM( 0, buffer0, TraceReader::TEXT_SHORT);
    TR.skipLine();
    CHECK_USER_CALL(glRasterPos2sv)
        UCT.glRasterPos2sv((const GLshort *)param[0].ptr);
    CHECK_GL_CALL(glRasterPos2sv)
        JT.glRasterPos2sv((const GLshort *)param[0].ptr);
}

void STUB_glRasterPos3d( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glRasterPos3d( GLdouble x, GLdouble y, GLdouble z )
    maxParam = 3;
    READ_DOUBLE_PARAM(0);
    READ_DOUBLE_PARAM(1);
    READ_DOUBLE_PARAM(2);
    TR.skipLine();
    CHECK_USER_CALL(glRasterPos3d)
        UCT.glRasterPos3d(param[0].fv64bit, param[1].fv64bit, param[2].fv64bit);
    CHECK_GL_CALL(glRasterPos3d)
        JT.glRasterPos3d(param[0].fv64bit, param[1].fv64bit, param[2].fv64bit);
}

void STUB_glRasterPos3dv( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glRasterPos3dv( const GLdouble *v )
    maxParam = 1;
    char buffer0[16*4096];
    READ_ARRAY_PARAM( 0, buffer0, TraceReader::TEXT_DOUBLE);
    TR.skipLine();
    CHECK_USER_CALL(glRasterPos3dv)
        UCT.glRasterPos3dv((const GLdouble *)param[0].ptr);
    CHECK_GL_CALL(glRasterPos3dv)
        JT.glRasterPos3dv((const GLdouble *)param[0].ptr);
}

void STUB_glRasterPos3f( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glRasterPos3f( GLfloat x, GLfloat y, GLfloat z )
    maxParam = 3;
    READ_PARAM(fv32bit,0);
    READ_PARAM(fv32bit,1);
    READ_PARAM(fv32bit,2);
    TR.skipLine();
    CHECK_USER_CALL(glRasterPos3f)
        UCT.glRasterPos3f(param[0].fv32bit, param[1].fv32bit, param[2].fv32bit);
    CHECK_GL_CALL(glRasterPos3f)
        JT.glRasterPos3f(param[0].fv32bit, param[1].fv32bit, param[2].fv32bit);
}

void STUB_glRasterPos3fv( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glRasterPos3fv( const GLfloat *v )
    maxParam = 1;
    char buffer0[16*4096];
    READ_ARRAY_PARAM( 0, buffer0, TraceReader::TEXT_FLOAT);
    TR.skipLine();
    CHECK_USER_CALL(glRasterPos3fv)
        UCT.glRasterPos3fv((const GLfloat *)param[0].ptr);
    CHECK_GL_CALL(glRasterPos3fv)
        JT.glRasterPos3fv((const GLfloat *)param[0].ptr);
}

void STUB_glRasterPos3i( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glRasterPos3i( GLint x, GLint y, GLint z )
    maxParam = 3;
    READ_PARAM(v32bit,0);
    READ_PARAM(v32bit,1);
    READ_PARAM(v32bit,2);
    TR.skipLine();
    CHECK_USER_CALL(glRasterPos3i)
        UCT.glRasterPos3i(param[0].v32bit, param[1].v32bit, param[2].v32bit);
    CHECK_GL_CALL(glRasterPos3i)
        JT.glRasterPos3i(param[0].v32bit, param[1].v32bit, param[2].v32bit);
}

void STUB_glRasterPos3iv( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glRasterPos3iv( const GLint *v )
    maxParam = 1;
    char buffer0[16*4096];
    READ_ARRAY_PARAM( 0, buffer0, TraceReader::TEXT_INT);
    TR.skipLine();
    CHECK_USER_CALL(glRasterPos3iv)
        UCT.glRasterPos3iv((const GLint *)param[0].ptr);
    CHECK_GL_CALL(glRasterPos3iv)
        JT.glRasterPos3iv((const GLint *)param[0].ptr);
}

void STUB_glRasterPos3s( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glRasterPos3s( GLshort x, GLshort y, GLshort z )
    maxParam = 3;
    READ_PARAM(v16bit,0);
    READ_PARAM(v16bit,1);
    READ_PARAM(v16bit,2);
    TR.skipLine();
    CHECK_USER_CALL(glRasterPos3s)
        UCT.glRasterPos3s(param[0].v16bit, param[1].v16bit, param[2].v16bit);
    CHECK_GL_CALL(glRasterPos3s)
        JT.glRasterPos3s(param[0].v16bit, param[1].v16bit, param[2].v16bit);
}

void STUB_glRasterPos3sv( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glRasterPos3sv( const GLshort *v )
    maxParam = 1;
    char buffer0[16*4096];
    READ_ARRAY_PARAM( 0, buffer0, TraceReader::TEXT_SHORT);
    TR.skipLine();
    CHECK_USER_CALL(glRasterPos3sv)
        UCT.glRasterPos3sv((const GLshort *)param[0].ptr);
    CHECK_GL_CALL(glRasterPos3sv)
        JT.glRasterPos3sv((const GLshort *)param[0].ptr);
}

void STUB_glRasterPos4d( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glRasterPos4d( GLdouble x, GLdouble y, GLdouble z, GLdouble w )
    maxParam = 4;
    READ_DOUBLE_PARAM(0);
    READ_DOUBLE_PARAM(1);
    READ_DOUBLE_PARAM(2);
    READ_DOUBLE_PARAM(3);
    TR.skipLine();
    CHECK_USER_CALL(glRasterPos4d)
        UCT.glRasterPos4d(param[0].fv64bit, param[1].fv64bit, param[2].fv64bit, param[3].fv64bit);
    CHECK_GL_CALL(glRasterPos4d)
        JT.glRasterPos4d(param[0].fv64bit, param[1].fv64bit, param[2].fv64bit, param[3].fv64bit);
}

void STUB_glRasterPos4dv( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glRasterPos4dv( const GLdouble *v )
    maxParam = 1;
    char buffer0[16*4096];
    READ_ARRAY_PARAM( 0, buffer0, TraceReader::TEXT_DOUBLE);
    TR.skipLine();
    CHECK_USER_CALL(glRasterPos4dv)
        UCT.glRasterPos4dv((const GLdouble *)param[0].ptr);
    CHECK_GL_CALL(glRasterPos4dv)
        JT.glRasterPos4dv((const GLdouble *)param[0].ptr);
}

void STUB_glRasterPos4f( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glRasterPos4f( GLfloat x, GLfloat y, GLfloat z, GLfloat w )
    maxParam = 4;
    READ_PARAM(fv32bit,0);
    READ_PARAM(fv32bit,1);
    READ_PARAM(fv32bit,2);
    READ_PARAM(fv32bit,3);
    TR.skipLine();
    CHECK_USER_CALL(glRasterPos4f)
        UCT.glRasterPos4f(param[0].fv32bit, param[1].fv32bit, param[2].fv32bit, param[3].fv32bit);
    CHECK_GL_CALL(glRasterPos4f)
        JT.glRasterPos4f(param[0].fv32bit, param[1].fv32bit, param[2].fv32bit, param[3].fv32bit);
}

void STUB_glRasterPos4fv( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glRasterPos4fv( const GLfloat *v )
    maxParam = 1;
    char buffer0[16*4096];
    READ_ARRAY_PARAM( 0, buffer0, TraceReader::TEXT_FLOAT);
    TR.skipLine();
    CHECK_USER_CALL(glRasterPos4fv)
        UCT.glRasterPos4fv((const GLfloat *)param[0].ptr);
    CHECK_GL_CALL(glRasterPos4fv)
        JT.glRasterPos4fv((const GLfloat *)param[0].ptr);
}

void STUB_glRasterPos4i( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glRasterPos4i( GLint x, GLint y, GLint z, GLint w )
    maxParam = 4;
    READ_PARAM(v32bit,0);
    READ_PARAM(v32bit,1);
    READ_PARAM(v32bit,2);
    READ_PARAM(v32bit,3);
    TR.skipLine();
    CHECK_USER_CALL(glRasterPos4i)
        UCT.glRasterPos4i(param[0].v32bit, param[1].v32bit, param[2].v32bit, param[3].v32bit);
    CHECK_GL_CALL(glRasterPos4i)
        JT.glRasterPos4i(param[0].v32bit, param[1].v32bit, param[2].v32bit, param[3].v32bit);
}

void STUB_glRasterPos4iv( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glRasterPos4iv( const GLint *v )
    maxParam = 1;
    char buffer0[16*4096];
    READ_ARRAY_PARAM( 0, buffer0, TraceReader::TEXT_INT);
    TR.skipLine();
    CHECK_USER_CALL(glRasterPos4iv)
        UCT.glRasterPos4iv((const GLint *)param[0].ptr);
    CHECK_GL_CALL(glRasterPos4iv)
        JT.glRasterPos4iv((const GLint *)param[0].ptr);
}

void STUB_glRasterPos4s( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glRasterPos4s( GLshort x, GLshort y, GLshort z, GLshort w )
    maxParam = 4;
    READ_PARAM(v16bit,0);
    READ_PARAM(v16bit,1);
    READ_PARAM(v16bit,2);
    READ_PARAM(v16bit,3);
    TR.skipLine();
    CHECK_USER_CALL(glRasterPos4s)
        UCT.glRasterPos4s(param[0].v16bit, param[1].v16bit, param[2].v16bit, param[3].v16bit);
    CHECK_GL_CALL(glRasterPos4s)
        JT.glRasterPos4s(param[0].v16bit, param[1].v16bit, param[2].v16bit, param[3].v16bit);
}

void STUB_glRasterPos4sv( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glRasterPos4sv( const GLshort *v )
    maxParam = 1;
    char buffer0[16*4096];
    READ_ARRAY_PARAM( 0, buffer0, TraceReader::TEXT_SHORT);
    TR.skipLine();
    CHECK_USER_CALL(glRasterPos4sv)
        UCT.glRasterPos4sv((const GLshort *)param[0].ptr);
    CHECK_GL_CALL(glRasterPos4sv)
        JT.glRasterPos4sv((const GLshort *)param[0].ptr);
}

void STUB_glReadBuffer( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glReadBuffer( GLenum mode )
    maxParam = 1;
    READ_ENUM_PARAM(0);
    TR.skipLine();
    CHECK_USER_CALL(glReadBuffer)
        UCT.glReadBuffer(param[0].uv32bit);
    CHECK_GL_CALL(glReadBuffer)
        JT.glReadBuffer(param[0].uv32bit);
}

void STUB_glReadInstrumentsSGIX( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glReadInstrumentsSGIX( GLint )
    maxParam = 1;
    READ_PARAM(v32bit,0);
    TR.skipLine();
    CHECK_USER_CALL(glReadInstrumentsSGIX)
        UCT.glReadInstrumentsSGIX(param[0].v32bit);
    CHECK_GL_CALL(glReadInstrumentsSGIX)
        JT.glReadInstrumentsSGIX(param[0].v32bit);
}

void STUB_glReadPixels( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glReadPixels( GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLvoid *pixels )
    maxParam = 7;
    char buffer0[16*4096];
    READ_PARAM(v32bit,0);
    READ_PARAM(v32bit,1);
    READ_PARAM(v32bit,2);
    READ_PARAM(v32bit,3);
    READ_ENUM_PARAM(4);
    READ_ENUM_PARAM(5);
    READ_ARRAY_PARAM( 6, buffer0, TraceReader::TEXT_IGNORE);
    TR.skipLine();
    CHECK_USER_CALL(glReadPixels)
        UCT.glReadPixels(param[0].v32bit, param[1].v32bit, param[2].v32bit, param[3].v32bit, param[4].uv32bit, param[5].uv32bit, (GLvoid *)param[6].ptr);
    CHECK_GL_CALL(glReadPixels)
        JT.glReadPixels(param[0].v32bit, param[1].v32bit, param[2].v32bit, param[3].v32bit, param[4].uv32bit, param[5].uv32bit, (GLvoid *)param[6].ptr);
}

void STUB_glRectd( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glRectd( GLdouble x1, GLdouble y1, GLdouble x2, GLdouble y2 )
    maxParam = 4;
    READ_DOUBLE_PARAM(0);
    READ_DOUBLE_PARAM(1);
    READ_DOUBLE_PARAM(2);
    READ_DOUBLE_PARAM(3);
    TR.skipLine();
    CHECK_USER_CALL(glRectd)
        UCT.glRectd(param[0].fv64bit, param[1].fv64bit, param[2].fv64bit, param[3].fv64bit);
    CHECK_GL_CALL(glRectd)
        JT.glRectd(param[0].fv64bit, param[1].fv64bit, param[2].fv64bit, param[3].fv64bit);
}

void STUB_glRectdv( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glRectdv( const GLdouble *v1, const GLdouble *v2 )
    maxParam = 2;
    char buffer0[16*4096];
    char buffer1[16*4096];
    READ_ARRAY_PARAM( 0, buffer0, TraceReader::TEXT_DOUBLE);
    READ_ARRAY_PARAM( 1, buffer1, TraceReader::TEXT_DOUBLE);
    TR.skipLine();
    CHECK_USER_CALL(glRectdv)
        UCT.glRectdv((const GLdouble *)param[0].ptr, (const GLdouble *)param[1].ptr);
    CHECK_GL_CALL(glRectdv)
        JT.glRectdv((const GLdouble *)param[0].ptr, (const GLdouble *)param[1].ptr);
}

void STUB_glRectf( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glRectf( GLfloat x1, GLfloat y1, GLfloat x2, GLfloat y2 )
    maxParam = 4;
    READ_PARAM(fv32bit,0);
    READ_PARAM(fv32bit,1);
    READ_PARAM(fv32bit,2);
    READ_PARAM(fv32bit,3);
    TR.skipLine();
    CHECK_USER_CALL(glRectf)
        UCT.glRectf(param[0].fv32bit, param[1].fv32bit, param[2].fv32bit, param[3].fv32bit);
    CHECK_GL_CALL(glRectf)
        JT.glRectf(param[0].fv32bit, param[1].fv32bit, param[2].fv32bit, param[3].fv32bit);
}

void STUB_glRectfv( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glRectfv( const GLfloat *v1, const GLfloat *v2 )
    maxParam = 2;
    char buffer0[16*4096];
    char buffer1[16*4096];
    READ_ARRAY_PARAM( 0, buffer0, TraceReader::TEXT_FLOAT);
    READ_ARRAY_PARAM( 1, buffer1, TraceReader::TEXT_FLOAT);
    TR.skipLine();
    CHECK_USER_CALL(glRectfv)
        UCT.glRectfv((const GLfloat *)param[0].ptr, (const GLfloat *)param[1].ptr);
    CHECK_GL_CALL(glRectfv)
        JT.glRectfv((const GLfloat *)param[0].ptr, (const GLfloat *)param[1].ptr);
}

void STUB_glRecti( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glRecti( GLint x1, GLint y1, GLint x2, GLint y2 )
    maxParam = 4;
    READ_PARAM(v32bit,0);
    READ_PARAM(v32bit,1);
    READ_PARAM(v32bit,2);
    READ_PARAM(v32bit,3);
    TR.skipLine();
    CHECK_USER_CALL(glRecti)
        UCT.glRecti(param[0].v32bit, param[1].v32bit, param[2].v32bit, param[3].v32bit);
    CHECK_GL_CALL(glRecti)
        JT.glRecti(param[0].v32bit, param[1].v32bit, param[2].v32bit, param[3].v32bit);
}

void STUB_glRectiv( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glRectiv( const GLint *v1, const GLint *v2 )
    maxParam = 2;
    char buffer0[16*4096];
    char buffer1[16*4096];
    READ_ARRAY_PARAM( 0, buffer0, TraceReader::TEXT_INT);
    READ_ARRAY_PARAM( 1, buffer1, TraceReader::TEXT_INT);
    TR.skipLine();
    CHECK_USER_CALL(glRectiv)
        UCT.glRectiv((const GLint *)param[0].ptr, (const GLint *)param[1].ptr);
    CHECK_GL_CALL(glRectiv)
        JT.glRectiv((const GLint *)param[0].ptr, (const GLint *)param[1].ptr);
}

void STUB_glRects( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glRects( GLshort x1, GLshort y1, GLshort x2, GLshort y2 )
    maxParam = 4;
    READ_PARAM(v16bit,0);
    READ_PARAM(v16bit,1);
    READ_PARAM(v16bit,2);
    READ_PARAM(v16bit,3);
    TR.skipLine();
    CHECK_USER_CALL(glRects)
        UCT.glRects(param[0].v16bit, param[1].v16bit, param[2].v16bit, param[3].v16bit);
    CHECK_GL_CALL(glRects)
        JT.glRects(param[0].v16bit, param[1].v16bit, param[2].v16bit, param[3].v16bit);
}

void STUB_glRectsv( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glRectsv( const GLshort *v1, const GLshort *v2 )
    maxParam = 2;
    char buffer0[16*4096];
    char buffer1[16*4096];
    READ_ARRAY_PARAM( 0, buffer0, TraceReader::TEXT_SHORT);
    READ_ARRAY_PARAM( 1, buffer1, TraceReader::TEXT_SHORT);
    TR.skipLine();
    CHECK_USER_CALL(glRectsv)
        UCT.glRectsv((const GLshort *)param[0].ptr, (const GLshort *)param[1].ptr);
    CHECK_GL_CALL(glRectsv)
        JT.glRectsv((const GLshort *)param[0].ptr, (const GLshort *)param[1].ptr);
}

void STUB_glReferencePlaneSGIX( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glReferencePlaneSGIX( const GLdouble * )
    maxParam = 1;
    char buffer0[16*4096];
    READ_ARRAY_PARAM( 0, buffer0, TraceReader::TEXT_DOUBLE);
    TR.skipLine();
    CHECK_USER_CALL(glReferencePlaneSGIX)
        UCT.glReferencePlaneSGIX((const GLdouble *)param[0].ptr);
    CHECK_GL_CALL(glReferencePlaneSGIX)
        JT.glReferencePlaneSGIX((const GLdouble *)param[0].ptr);
}

void STUB_glRenderMode( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // GLint glRenderMode( GLenum mode )
    maxParam = 1;
    READ_ENUM_PARAM(0);
    TR.skipResult();
    TR.skipLine();
    CHECK_USER_CALL(glRenderMode)
        UCT.glRenderMode(param[0].uv32bit);
    CHECK_GL_CALL(glRenderMode)
        JT.glRenderMode(param[0].uv32bit);
}

void STUB_glRenderbufferStorage( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glRenderbufferStorage( GLenum, GLenum, GLsizei, GLsizei )
    maxParam = 4;
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_PARAM(v32bit,2);
    READ_PARAM(v32bit,3);
    TR.skipLine();
    CHECK_USER_CALL(glRenderbufferStorage)
        UCT.glRenderbufferStorage(param[0].uv32bit, param[1].uv32bit, param[2].v32bit, param[3].v32bit);
    CHECK_GL_CALL(glRenderbufferStorage)
        JT.glRenderbufferStorage(param[0].uv32bit, param[1].uv32bit, param[2].v32bit, param[3].v32bit);
}

void STUB_glRenderbufferStorageEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glRenderbufferStorageEXT( GLenum, GLenum, GLsizei, GLsizei )
    maxParam = 4;
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_PARAM(v32bit,2);
    READ_PARAM(v32bit,3);
    TR.skipLine();
    CHECK_USER_CALL(glRenderbufferStorageEXT)
        UCT.glRenderbufferStorageEXT(param[0].uv32bit, param[1].uv32bit, param[2].v32bit, param[3].v32bit);
    CHECK_GL_CALL(glRenderbufferStorageEXT)
        JT.glRenderbufferStorageEXT(param[0].uv32bit, param[1].uv32bit, param[2].v32bit, param[3].v32bit);
}

void STUB_glRenderbufferStorageMultisample( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glRenderbufferStorageMultisample( GLenum, GLsizei, GLenum, GLsizei, GLsizei )
    maxParam = 5;
    READ_ENUM_PARAM(0);
    READ_PARAM(v32bit,1);
    READ_ENUM_PARAM(2);
    READ_PARAM(v32bit,3);
    READ_PARAM(v32bit,4);
    TR.skipLine();
    CHECK_USER_CALL(glRenderbufferStorageMultisample)
        UCT.glRenderbufferStorageMultisample(param[0].uv32bit, param[1].v32bit, param[2].uv32bit, param[3].v32bit, param[4].v32bit);
    CHECK_GL_CALL(glRenderbufferStorageMultisample)
        JT.glRenderbufferStorageMultisample(param[0].uv32bit, param[1].v32bit, param[2].uv32bit, param[3].v32bit, param[4].v32bit);
}

void STUB_glRenderbufferStorageMultisampleCoverageNV( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glRenderbufferStorageMultisampleCoverageNV( GLenum, GLsizei, GLsizei, GLenum, GLsizei, GLsizei )
    maxParam = 6;
    READ_ENUM_PARAM(0);
    READ_PARAM(v32bit,1);
    READ_PARAM(v32bit,2);
    READ_ENUM_PARAM(3);
    READ_PARAM(v32bit,4);
    READ_PARAM(v32bit,5);
    TR.skipLine();
    CHECK_USER_CALL(glRenderbufferStorageMultisampleCoverageNV)
        UCT.glRenderbufferStorageMultisampleCoverageNV(param[0].uv32bit, param[1].v32bit, param[2].v32bit, param[3].uv32bit, param[4].v32bit, param[5].v32bit);
    CHECK_GL_CALL(glRenderbufferStorageMultisampleCoverageNV)
        JT.glRenderbufferStorageMultisampleCoverageNV(param[0].uv32bit, param[1].v32bit, param[2].v32bit, param[3].uv32bit, param[4].v32bit, param[5].v32bit);
}

void STUB_glRenderbufferStorageMultisampleEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glRenderbufferStorageMultisampleEXT( GLenum, GLsizei, GLenum, GLsizei, GLsizei )
    maxParam = 5;
    READ_ENUM_PARAM(0);
    READ_PARAM(v32bit,1);
    READ_ENUM_PARAM(2);
    READ_PARAM(v32bit,3);
    READ_PARAM(v32bit,4);
    TR.skipLine();
    CHECK_USER_CALL(glRenderbufferStorageMultisampleEXT)
        UCT.glRenderbufferStorageMultisampleEXT(param[0].uv32bit, param[1].v32bit, param[2].uv32bit, param[3].v32bit, param[4].v32bit);
    CHECK_GL_CALL(glRenderbufferStorageMultisampleEXT)
        JT.glRenderbufferStorageMultisampleEXT(param[0].uv32bit, param[1].v32bit, param[2].uv32bit, param[3].v32bit, param[4].v32bit);
}

void STUB_glRequestResidentProgramsNV( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glRequestResidentProgramsNV( GLsizei, const GLuint * )
    maxParam = 2;
    char buffer0[16*4096];
    READ_PARAM(v32bit,0);
    READ_ARRAY_PARAM( 1, buffer0, TraceReader::TEXT_INT);
    TR.skipLine();
    CHECK_USER_CALL(glRequestResidentProgramsNV)
        UCT.glRequestResidentProgramsNV(param[0].v32bit, (const GLuint *)param[1].ptr);
    CHECK_GL_CALL(glRequestResidentProgramsNV)
        JT.glRequestResidentProgramsNV(param[0].v32bit, (const GLuint *)param[1].ptr);
}

void STUB_glResetHistogram( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glResetHistogram( GLenum target )
    maxParam = 1;
    READ_ENUM_PARAM(0);
    TR.skipLine();
    CHECK_USER_CALL(glResetHistogram)
        UCT.glResetHistogram(param[0].uv32bit);
    CHECK_GL_CALL(glResetHistogram)
        JT.glResetHistogram(param[0].uv32bit);
}

void STUB_glResetHistogramEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glResetHistogramEXT( GLenum )
    maxParam = 1;
    READ_ENUM_PARAM(0);
    TR.skipLine();
    CHECK_USER_CALL(glResetHistogramEXT)
        UCT.glResetHistogramEXT(param[0].uv32bit);
    CHECK_GL_CALL(glResetHistogramEXT)
        JT.glResetHistogramEXT(param[0].uv32bit);
}

void STUB_glResetMinmax( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glResetMinmax( GLenum target )
    maxParam = 1;
    READ_ENUM_PARAM(0);
    TR.skipLine();
    CHECK_USER_CALL(glResetMinmax)
        UCT.glResetMinmax(param[0].uv32bit);
    CHECK_GL_CALL(glResetMinmax)
        JT.glResetMinmax(param[0].uv32bit);
}

void STUB_glResetMinmaxEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glResetMinmaxEXT( GLenum )
    maxParam = 1;
    READ_ENUM_PARAM(0);
    TR.skipLine();
    CHECK_USER_CALL(glResetMinmaxEXT)
        UCT.glResetMinmaxEXT(param[0].uv32bit);
    CHECK_GL_CALL(glResetMinmaxEXT)
        JT.glResetMinmaxEXT(param[0].uv32bit);
}

void STUB_glResumeTransformFeedbackNV( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glResumeTransformFeedbackNV(  )
    maxParam = 0;
    TR.skipLine();
    CHECK_USER_CALL(glResumeTransformFeedbackNV)
        UCT.glResumeTransformFeedbackNV();
    CHECK_GL_CALL(glResumeTransformFeedbackNV)
        JT.glResumeTransformFeedbackNV();
}

void STUB_glRotated( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glRotated( GLdouble angle, GLdouble x, GLdouble y, GLdouble z )
    maxParam = 4;
    READ_DOUBLE_PARAM(0);
    READ_DOUBLE_PARAM(1);
    READ_DOUBLE_PARAM(2);
    READ_DOUBLE_PARAM(3);
    TR.skipLine();
    CHECK_USER_CALL(glRotated)
        UCT.glRotated(param[0].fv64bit, param[1].fv64bit, param[2].fv64bit, param[3].fv64bit);
    CHECK_GL_CALL(glRotated)
        JT.glRotated(param[0].fv64bit, param[1].fv64bit, param[2].fv64bit, param[3].fv64bit);
}

void STUB_glRotatef( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glRotatef( GLfloat angle, GLfloat x, GLfloat y, GLfloat z )
    maxParam = 4;
    READ_PARAM(fv32bit,0);
    READ_PARAM(fv32bit,1);
    READ_PARAM(fv32bit,2);
    READ_PARAM(fv32bit,3);
    TR.skipLine();
    CHECK_USER_CALL(glRotatef)
        UCT.glRotatef(param[0].fv32bit, param[1].fv32bit, param[2].fv32bit, param[3].fv32bit);
    CHECK_GL_CALL(glRotatef)
        JT.glRotatef(param[0].fv32bit, param[1].fv32bit, param[2].fv32bit, param[3].fv32bit);
}

void STUB_glSampleCoverage( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glSampleCoverage( GLclampf value, GLboolean invert )
    maxParam = 2;
    READ_PARAM(fv32bit,0);
    READ_BOOLEAN_PARAM(1);
    TR.skipLine();
    CHECK_USER_CALL(glSampleCoverage)
        UCT.glSampleCoverage(param[0].fv32bit, param[1].boolean);
    CHECK_GL_CALL(glSampleCoverage)
        JT.glSampleCoverage(param[0].fv32bit, param[1].boolean);
}

void STUB_glSampleCoverageARB( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glSampleCoverageARB( GLclampf, GLboolean )
    maxParam = 2;
    READ_PARAM(fv32bit,0);
    READ_BOOLEAN_PARAM(1);
    TR.skipLine();
    CHECK_USER_CALL(glSampleCoverageARB)
        UCT.glSampleCoverageARB(param[0].fv32bit, param[1].boolean);
    CHECK_GL_CALL(glSampleCoverageARB)
        JT.glSampleCoverageARB(param[0].fv32bit, param[1].boolean);
}

void STUB_glSampleMapATI( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glSampleMapATI( GLuint, GLuint, GLenum )
    maxParam = 3;
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_ENUM_PARAM(2);
    TR.skipLine();
    CHECK_USER_CALL(glSampleMapATI)
        UCT.glSampleMapATI(param[0].uv32bit, param[1].uv32bit, param[2].uv32bit);
    CHECK_GL_CALL(glSampleMapATI)
        JT.glSampleMapATI(param[0].uv32bit, param[1].uv32bit, param[2].uv32bit);
}

void STUB_glSampleMaskEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glSampleMaskEXT( GLclampf, GLboolean )
    maxParam = 2;
    READ_PARAM(fv32bit,0);
    READ_BOOLEAN_PARAM(1);
    TR.skipLine();
    CHECK_USER_CALL(glSampleMaskEXT)
        UCT.glSampleMaskEXT(param[0].fv32bit, param[1].boolean);
    CHECK_GL_CALL(glSampleMaskEXT)
        JT.glSampleMaskEXT(param[0].fv32bit, param[1].boolean);
}

void STUB_glSampleMaskIndexedNV( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glSampleMaskIndexedNV( GLuint, GLbitfield )
    maxParam = 2;
    READ_ENUM_PARAM(0);
    READ_ORING_PARAM(1);
    TR.skipLine();
    CHECK_USER_CALL(glSampleMaskIndexedNV)
        UCT.glSampleMaskIndexedNV(param[0].uv32bit, param[1].uv32bit);
    CHECK_GL_CALL(glSampleMaskIndexedNV)
        JT.glSampleMaskIndexedNV(param[0].uv32bit, param[1].uv32bit);
}

void STUB_glSampleMaskSGIS( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glSampleMaskSGIS( GLclampf, GLboolean )
    maxParam = 2;
    READ_PARAM(fv32bit,0);
    READ_BOOLEAN_PARAM(1);
    TR.skipLine();
    CHECK_USER_CALL(glSampleMaskSGIS)
        UCT.glSampleMaskSGIS(param[0].fv32bit, param[1].boolean);
    CHECK_GL_CALL(glSampleMaskSGIS)
        JT.glSampleMaskSGIS(param[0].fv32bit, param[1].boolean);
}

void STUB_glSamplePatternEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glSamplePatternEXT( GLenum )
    maxParam = 1;
    READ_ENUM_PARAM(0);
    TR.skipLine();
    CHECK_USER_CALL(glSamplePatternEXT)
        UCT.glSamplePatternEXT(param[0].uv32bit);
    CHECK_GL_CALL(glSamplePatternEXT)
        JT.glSamplePatternEXT(param[0].uv32bit);
}

void STUB_glSamplePatternSGIS( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glSamplePatternSGIS( GLenum )
    maxParam = 1;
    READ_ENUM_PARAM(0);
    TR.skipLine();
    CHECK_USER_CALL(glSamplePatternSGIS)
        UCT.glSamplePatternSGIS(param[0].uv32bit);
    CHECK_GL_CALL(glSamplePatternSGIS)
        JT.glSamplePatternSGIS(param[0].uv32bit);
}

void STUB_glScaled( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glScaled( GLdouble x, GLdouble y, GLdouble z )
    maxParam = 3;
    READ_DOUBLE_PARAM(0);
    READ_DOUBLE_PARAM(1);
    READ_DOUBLE_PARAM(2);
    TR.skipLine();
    CHECK_USER_CALL(glScaled)
        UCT.glScaled(param[0].fv64bit, param[1].fv64bit, param[2].fv64bit);
    CHECK_GL_CALL(glScaled)
        JT.glScaled(param[0].fv64bit, param[1].fv64bit, param[2].fv64bit);
}

void STUB_glScalef( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glScalef( GLfloat x, GLfloat y, GLfloat z )
    maxParam = 3;
    READ_PARAM(fv32bit,0);
    READ_PARAM(fv32bit,1);
    READ_PARAM(fv32bit,2);
    TR.skipLine();
    CHECK_USER_CALL(glScalef)
        UCT.glScalef(param[0].fv32bit, param[1].fv32bit, param[2].fv32bit);
    CHECK_GL_CALL(glScalef)
        JT.glScalef(param[0].fv32bit, param[1].fv32bit, param[2].fv32bit);
}

void STUB_glScissor( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glScissor( GLint x, GLint y, GLsizei width, GLsizei height )
    maxParam = 4;
    READ_PARAM(v32bit,0);
    READ_PARAM(v32bit,1);
    READ_PARAM(v32bit,2);
    READ_PARAM(v32bit,3);
    TR.skipLine();
    CHECK_USER_CALL(glScissor)
        UCT.glScissor(param[0].v32bit, param[1].v32bit, param[2].v32bit, param[3].v32bit);
    CHECK_GL_CALL(glScissor)
        JT.glScissor(param[0].v32bit, param[1].v32bit, param[2].v32bit, param[3].v32bit);
}

void STUB_glSecondaryColor3b( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glSecondaryColor3b( GLbyte, GLbyte, GLbyte )
    maxParam = 3;
    READ_PARAM(v8bit,0);
    READ_PARAM(v8bit,1);
    READ_PARAM(v8bit,2);
    TR.skipLine();
    CHECK_USER_CALL(glSecondaryColor3b)
        UCT.glSecondaryColor3b(param[0].v8bit, param[1].v8bit, param[2].v8bit);
    CHECK_GL_CALL(glSecondaryColor3b)
        JT.glSecondaryColor3b(param[0].v8bit, param[1].v8bit, param[2].v8bit);
}

void STUB_glSecondaryColor3bEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glSecondaryColor3bEXT( GLbyte, GLbyte, GLbyte )
    maxParam = 3;
    READ_PARAM(v8bit,0);
    READ_PARAM(v8bit,1);
    READ_PARAM(v8bit,2);
    TR.skipLine();
    CHECK_USER_CALL(glSecondaryColor3bEXT)
        UCT.glSecondaryColor3bEXT(param[0].v8bit, param[1].v8bit, param[2].v8bit);
    CHECK_GL_CALL(glSecondaryColor3bEXT)
        JT.glSecondaryColor3bEXT(param[0].v8bit, param[1].v8bit, param[2].v8bit);
}

void STUB_glSecondaryColor3bv( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glSecondaryColor3bv( const GLbyte * )
    maxParam = 1;
    char buffer0[16*4096];
    READ_ARRAY_PARAM( 0, buffer0, TraceReader::TEXT_BYTE);
    TR.skipLine();
    CHECK_USER_CALL(glSecondaryColor3bv)
        UCT.glSecondaryColor3bv((const GLbyte *)param[0].ptr);
    CHECK_GL_CALL(glSecondaryColor3bv)
        JT.glSecondaryColor3bv((const GLbyte *)param[0].ptr);
}

void STUB_glSecondaryColor3bvEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glSecondaryColor3bvEXT( const GLbyte * )
    maxParam = 1;
    char buffer0[16*4096];
    READ_ARRAY_PARAM( 0, buffer0, TraceReader::TEXT_BYTE);
    TR.skipLine();
    CHECK_USER_CALL(glSecondaryColor3bvEXT)
        UCT.glSecondaryColor3bvEXT((const GLbyte *)param[0].ptr);
    CHECK_GL_CALL(glSecondaryColor3bvEXT)
        JT.glSecondaryColor3bvEXT((const GLbyte *)param[0].ptr);
}

void STUB_glSecondaryColor3d( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glSecondaryColor3d( GLdouble, GLdouble, GLdouble )
    maxParam = 3;
    READ_DOUBLE_PARAM(0);
    READ_DOUBLE_PARAM(1);
    READ_DOUBLE_PARAM(2);
    TR.skipLine();
    CHECK_USER_CALL(glSecondaryColor3d)
        UCT.glSecondaryColor3d(param[0].fv64bit, param[1].fv64bit, param[2].fv64bit);
    CHECK_GL_CALL(glSecondaryColor3d)
        JT.glSecondaryColor3d(param[0].fv64bit, param[1].fv64bit, param[2].fv64bit);
}

void STUB_glSecondaryColor3dEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glSecondaryColor3dEXT( GLdouble, GLdouble, GLdouble )
    maxParam = 3;
    READ_DOUBLE_PARAM(0);
    READ_DOUBLE_PARAM(1);
    READ_DOUBLE_PARAM(2);
    TR.skipLine();
    CHECK_USER_CALL(glSecondaryColor3dEXT)
        UCT.glSecondaryColor3dEXT(param[0].fv64bit, param[1].fv64bit, param[2].fv64bit);
    CHECK_GL_CALL(glSecondaryColor3dEXT)
        JT.glSecondaryColor3dEXT(param[0].fv64bit, param[1].fv64bit, param[2].fv64bit);
}

void STUB_glSecondaryColor3dv( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glSecondaryColor3dv( const GLdouble * )
    maxParam = 1;
    char buffer0[16*4096];
    READ_ARRAY_PARAM( 0, buffer0, TraceReader::TEXT_DOUBLE);
    TR.skipLine();
    CHECK_USER_CALL(glSecondaryColor3dv)
        UCT.glSecondaryColor3dv((const GLdouble *)param[0].ptr);
    CHECK_GL_CALL(glSecondaryColor3dv)
        JT.glSecondaryColor3dv((const GLdouble *)param[0].ptr);
}

void STUB_glSecondaryColor3dvEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glSecondaryColor3dvEXT( const GLdouble * )
    maxParam = 1;
    char buffer0[16*4096];
    READ_ARRAY_PARAM( 0, buffer0, TraceReader::TEXT_DOUBLE);
    TR.skipLine();
    CHECK_USER_CALL(glSecondaryColor3dvEXT)
        UCT.glSecondaryColor3dvEXT((const GLdouble *)param[0].ptr);
    CHECK_GL_CALL(glSecondaryColor3dvEXT)
        JT.glSecondaryColor3dvEXT((const GLdouble *)param[0].ptr);
}

void STUB_glSecondaryColor3f( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glSecondaryColor3f( GLfloat, GLfloat, GLfloat )
    maxParam = 3;
    READ_PARAM(fv32bit,0);
    READ_PARAM(fv32bit,1);
    READ_PARAM(fv32bit,2);
    TR.skipLine();
    CHECK_USER_CALL(glSecondaryColor3f)
        UCT.glSecondaryColor3f(param[0].fv32bit, param[1].fv32bit, param[2].fv32bit);
    CHECK_GL_CALL(glSecondaryColor3f)
        JT.glSecondaryColor3f(param[0].fv32bit, param[1].fv32bit, param[2].fv32bit);
}

void STUB_glSecondaryColor3fEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glSecondaryColor3fEXT( GLfloat, GLfloat, GLfloat )
    maxParam = 3;
    READ_PARAM(fv32bit,0);
    READ_PARAM(fv32bit,1);
    READ_PARAM(fv32bit,2);
    TR.skipLine();
    CHECK_USER_CALL(glSecondaryColor3fEXT)
        UCT.glSecondaryColor3fEXT(param[0].fv32bit, param[1].fv32bit, param[2].fv32bit);
    CHECK_GL_CALL(glSecondaryColor3fEXT)
        JT.glSecondaryColor3fEXT(param[0].fv32bit, param[1].fv32bit, param[2].fv32bit);
}

void STUB_glSecondaryColor3fv( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glSecondaryColor3fv( const GLfloat * )
    maxParam = 1;
    char buffer0[16*4096];
    READ_ARRAY_PARAM( 0, buffer0, TraceReader::TEXT_FLOAT);
    TR.skipLine();
    CHECK_USER_CALL(glSecondaryColor3fv)
        UCT.glSecondaryColor3fv((const GLfloat *)param[0].ptr);
    CHECK_GL_CALL(glSecondaryColor3fv)
        JT.glSecondaryColor3fv((const GLfloat *)param[0].ptr);
}

void STUB_glSecondaryColor3fvEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glSecondaryColor3fvEXT( const GLfloat * )
    maxParam = 1;
    char buffer0[16*4096];
    READ_ARRAY_PARAM( 0, buffer0, TraceReader::TEXT_FLOAT);
    TR.skipLine();
    CHECK_USER_CALL(glSecondaryColor3fvEXT)
        UCT.glSecondaryColor3fvEXT((const GLfloat *)param[0].ptr);
    CHECK_GL_CALL(glSecondaryColor3fvEXT)
        JT.glSecondaryColor3fvEXT((const GLfloat *)param[0].ptr);
}

void STUB_glSecondaryColor3hNV( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glSecondaryColor3hNV( GLhalfNV, GLhalfNV, GLhalfNV )
    // Call not playable
    TR.skipCall();
}

void STUB_glSecondaryColor3hvNV( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glSecondaryColor3hvNV( const GLhalfNV * )
    // Call not playable
    TR.skipCall();
}

void STUB_glSecondaryColor3i( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glSecondaryColor3i( GLint, GLint, GLint )
    maxParam = 3;
    READ_PARAM(v32bit,0);
    READ_PARAM(v32bit,1);
    READ_PARAM(v32bit,2);
    TR.skipLine();
    CHECK_USER_CALL(glSecondaryColor3i)
        UCT.glSecondaryColor3i(param[0].v32bit, param[1].v32bit, param[2].v32bit);
    CHECK_GL_CALL(glSecondaryColor3i)
        JT.glSecondaryColor3i(param[0].v32bit, param[1].v32bit, param[2].v32bit);
}

void STUB_glSecondaryColor3iEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glSecondaryColor3iEXT( GLint, GLint, GLint )
    maxParam = 3;
    READ_PARAM(v32bit,0);
    READ_PARAM(v32bit,1);
    READ_PARAM(v32bit,2);
    TR.skipLine();
    CHECK_USER_CALL(glSecondaryColor3iEXT)
        UCT.glSecondaryColor3iEXT(param[0].v32bit, param[1].v32bit, param[2].v32bit);
    CHECK_GL_CALL(glSecondaryColor3iEXT)
        JT.glSecondaryColor3iEXT(param[0].v32bit, param[1].v32bit, param[2].v32bit);
}

void STUB_glSecondaryColor3iv( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glSecondaryColor3iv( const GLint * )
    maxParam = 1;
    char buffer0[16*4096];
    READ_ARRAY_PARAM( 0, buffer0, TraceReader::TEXT_INT);
    TR.skipLine();
    CHECK_USER_CALL(glSecondaryColor3iv)
        UCT.glSecondaryColor3iv((const GLint *)param[0].ptr);
    CHECK_GL_CALL(glSecondaryColor3iv)
        JT.glSecondaryColor3iv((const GLint *)param[0].ptr);
}

void STUB_glSecondaryColor3ivEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glSecondaryColor3ivEXT( const GLint * )
    maxParam = 1;
    char buffer0[16*4096];
    READ_ARRAY_PARAM( 0, buffer0, TraceReader::TEXT_INT);
    TR.skipLine();
    CHECK_USER_CALL(glSecondaryColor3ivEXT)
        UCT.glSecondaryColor3ivEXT((const GLint *)param[0].ptr);
    CHECK_GL_CALL(glSecondaryColor3ivEXT)
        JT.glSecondaryColor3ivEXT((const GLint *)param[0].ptr);
}

void STUB_glSecondaryColor3s( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glSecondaryColor3s( GLshort, GLshort, GLshort )
    maxParam = 3;
    READ_PARAM(v16bit,0);
    READ_PARAM(v16bit,1);
    READ_PARAM(v16bit,2);
    TR.skipLine();
    CHECK_USER_CALL(glSecondaryColor3s)
        UCT.glSecondaryColor3s(param[0].v16bit, param[1].v16bit, param[2].v16bit);
    CHECK_GL_CALL(glSecondaryColor3s)
        JT.glSecondaryColor3s(param[0].v16bit, param[1].v16bit, param[2].v16bit);
}

void STUB_glSecondaryColor3sEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glSecondaryColor3sEXT( GLshort, GLshort, GLshort )
    maxParam = 3;
    READ_PARAM(v16bit,0);
    READ_PARAM(v16bit,1);
    READ_PARAM(v16bit,2);
    TR.skipLine();
    CHECK_USER_CALL(glSecondaryColor3sEXT)
        UCT.glSecondaryColor3sEXT(param[0].v16bit, param[1].v16bit, param[2].v16bit);
    CHECK_GL_CALL(glSecondaryColor3sEXT)
        JT.glSecondaryColor3sEXT(param[0].v16bit, param[1].v16bit, param[2].v16bit);
}

void STUB_glSecondaryColor3sv( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glSecondaryColor3sv( const GLshort * )
    maxParam = 1;
    char buffer0[16*4096];
    READ_ARRAY_PARAM( 0, buffer0, TraceReader::TEXT_SHORT);
    TR.skipLine();
    CHECK_USER_CALL(glSecondaryColor3sv)
        UCT.glSecondaryColor3sv((const GLshort *)param[0].ptr);
    CHECK_GL_CALL(glSecondaryColor3sv)
        JT.glSecondaryColor3sv((const GLshort *)param[0].ptr);
}

void STUB_glSecondaryColor3svEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glSecondaryColor3svEXT( const GLshort * )
    maxParam = 1;
    char buffer0[16*4096];
    READ_ARRAY_PARAM( 0, buffer0, TraceReader::TEXT_SHORT);
    TR.skipLine();
    CHECK_USER_CALL(glSecondaryColor3svEXT)
        UCT.glSecondaryColor3svEXT((const GLshort *)param[0].ptr);
    CHECK_GL_CALL(glSecondaryColor3svEXT)
        JT.glSecondaryColor3svEXT((const GLshort *)param[0].ptr);
}

void STUB_glSecondaryColor3ub( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glSecondaryColor3ub( GLubyte, GLubyte, GLubyte )
    maxParam = 3;
    READ_PARAM(uv8bit,0);
    READ_PARAM(uv8bit,1);
    READ_PARAM(uv8bit,2);
    TR.skipLine();
    CHECK_USER_CALL(glSecondaryColor3ub)
        UCT.glSecondaryColor3ub(param[0].uv8bit, param[1].uv8bit, param[2].uv8bit);
    CHECK_GL_CALL(glSecondaryColor3ub)
        JT.glSecondaryColor3ub(param[0].uv8bit, param[1].uv8bit, param[2].uv8bit);
}

void STUB_glSecondaryColor3ubEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glSecondaryColor3ubEXT( GLubyte, GLubyte, GLubyte )
    maxParam = 3;
    READ_PARAM(uv8bit,0);
    READ_PARAM(uv8bit,1);
    READ_PARAM(uv8bit,2);
    TR.skipLine();
    CHECK_USER_CALL(glSecondaryColor3ubEXT)
        UCT.glSecondaryColor3ubEXT(param[0].uv8bit, param[1].uv8bit, param[2].uv8bit);
    CHECK_GL_CALL(glSecondaryColor3ubEXT)
        JT.glSecondaryColor3ubEXT(param[0].uv8bit, param[1].uv8bit, param[2].uv8bit);
}

void STUB_glSecondaryColor3ubv( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glSecondaryColor3ubv( const GLubyte * )
    maxParam = 1;
    char buffer0[16*4096];
    READ_ARRAY_PARAM( 0, buffer0, TraceReader::TEXT_BYTE);
    TR.skipLine();
    CHECK_USER_CALL(glSecondaryColor3ubv)
        UCT.glSecondaryColor3ubv((const GLubyte *)param[0].ptr);
    CHECK_GL_CALL(glSecondaryColor3ubv)
        JT.glSecondaryColor3ubv((const GLubyte *)param[0].ptr);
}

void STUB_glSecondaryColor3ubvEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glSecondaryColor3ubvEXT( const GLubyte * )
    maxParam = 1;
    char buffer0[16*4096];
    READ_ARRAY_PARAM( 0, buffer0, TraceReader::TEXT_BYTE);
    TR.skipLine();
    CHECK_USER_CALL(glSecondaryColor3ubvEXT)
        UCT.glSecondaryColor3ubvEXT((const GLubyte *)param[0].ptr);
    CHECK_GL_CALL(glSecondaryColor3ubvEXT)
        JT.glSecondaryColor3ubvEXT((const GLubyte *)param[0].ptr);
}

void STUB_glSecondaryColor3ui( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glSecondaryColor3ui( GLuint, GLuint, GLuint )
    maxParam = 3;
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_ENUM_PARAM(2);
    TR.skipLine();
    CHECK_USER_CALL(glSecondaryColor3ui)
        UCT.glSecondaryColor3ui(param[0].uv32bit, param[1].uv32bit, param[2].uv32bit);
    CHECK_GL_CALL(glSecondaryColor3ui)
        JT.glSecondaryColor3ui(param[0].uv32bit, param[1].uv32bit, param[2].uv32bit);
}

void STUB_glSecondaryColor3uiEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glSecondaryColor3uiEXT( GLuint, GLuint, GLuint )
    maxParam = 3;
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_ENUM_PARAM(2);
    TR.skipLine();
    CHECK_USER_CALL(glSecondaryColor3uiEXT)
        UCT.glSecondaryColor3uiEXT(param[0].uv32bit, param[1].uv32bit, param[2].uv32bit);
    CHECK_GL_CALL(glSecondaryColor3uiEXT)
        JT.glSecondaryColor3uiEXT(param[0].uv32bit, param[1].uv32bit, param[2].uv32bit);
}

void STUB_glSecondaryColor3uiv( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glSecondaryColor3uiv( const GLuint * )
    maxParam = 1;
    char buffer0[16*4096];
    READ_ARRAY_PARAM( 0, buffer0, TraceReader::TEXT_INT);
    TR.skipLine();
    CHECK_USER_CALL(glSecondaryColor3uiv)
        UCT.glSecondaryColor3uiv((const GLuint *)param[0].ptr);
    CHECK_GL_CALL(glSecondaryColor3uiv)
        JT.glSecondaryColor3uiv((const GLuint *)param[0].ptr);
}

void STUB_glSecondaryColor3uivEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glSecondaryColor3uivEXT( const GLuint * )
    maxParam = 1;
    char buffer0[16*4096];
    READ_ARRAY_PARAM( 0, buffer0, TraceReader::TEXT_INT);
    TR.skipLine();
    CHECK_USER_CALL(glSecondaryColor3uivEXT)
        UCT.glSecondaryColor3uivEXT((const GLuint *)param[0].ptr);
    CHECK_GL_CALL(glSecondaryColor3uivEXT)
        JT.glSecondaryColor3uivEXT((const GLuint *)param[0].ptr);
}

void STUB_glSecondaryColor3us( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glSecondaryColor3us( GLushort, GLushort, GLushort )
    maxParam = 3;
    READ_PARAM(uv16bit,0);
    READ_PARAM(uv16bit,1);
    READ_PARAM(uv16bit,2);
    TR.skipLine();
    CHECK_USER_CALL(glSecondaryColor3us)
        UCT.glSecondaryColor3us(param[0].uv16bit, param[1].uv16bit, param[2].uv16bit);
    CHECK_GL_CALL(glSecondaryColor3us)
        JT.glSecondaryColor3us(param[0].uv16bit, param[1].uv16bit, param[2].uv16bit);
}

void STUB_glSecondaryColor3usEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glSecondaryColor3usEXT( GLushort, GLushort, GLushort )
    maxParam = 3;
    READ_PARAM(uv16bit,0);
    READ_PARAM(uv16bit,1);
    READ_PARAM(uv16bit,2);
    TR.skipLine();
    CHECK_USER_CALL(glSecondaryColor3usEXT)
        UCT.glSecondaryColor3usEXT(param[0].uv16bit, param[1].uv16bit, param[2].uv16bit);
    CHECK_GL_CALL(glSecondaryColor3usEXT)
        JT.glSecondaryColor3usEXT(param[0].uv16bit, param[1].uv16bit, param[2].uv16bit);
}

void STUB_glSecondaryColor3usv( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glSecondaryColor3usv( const GLushort * )
    maxParam = 1;
    char buffer0[16*4096];
    READ_ARRAY_PARAM( 0, buffer0, TraceReader::TEXT_SHORT);
    TR.skipLine();
    CHECK_USER_CALL(glSecondaryColor3usv)
        UCT.glSecondaryColor3usv((const GLushort *)param[0].ptr);
    CHECK_GL_CALL(glSecondaryColor3usv)
        JT.glSecondaryColor3usv((const GLushort *)param[0].ptr);
}

void STUB_glSecondaryColor3usvEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glSecondaryColor3usvEXT( const GLushort * )
    maxParam = 1;
    char buffer0[16*4096];
    READ_ARRAY_PARAM( 0, buffer0, TraceReader::TEXT_SHORT);
    TR.skipLine();
    CHECK_USER_CALL(glSecondaryColor3usvEXT)
        UCT.glSecondaryColor3usvEXT((const GLushort *)param[0].ptr);
    CHECK_GL_CALL(glSecondaryColor3usvEXT)
        JT.glSecondaryColor3usvEXT((const GLushort *)param[0].ptr);
}

void STUB_glSecondaryColorPointer( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glSecondaryColorPointer( GLint, GLenum, GLsizei, const GLvoid * )
    maxParam = 4;
    char buffer0[16*4096];
    READ_PARAM(v32bit,0);
    READ_ENUM_PARAM(1);
    READ_PARAM(v32bit,2);
    READ_ARRAY_PARAM( 3, buffer0, TraceReader::TEXT_IGNORE);
    TR.skipLine();
    CHECK_USER_CALL(glSecondaryColorPointer)
        UCT.glSecondaryColorPointer(param[0].v32bit, param[1].uv32bit, param[2].v32bit, (const GLvoid *)param[3].ptr);
    CHECK_GL_CALL(glSecondaryColorPointer)
        JT.glSecondaryColorPointer(param[0].v32bit, param[1].uv32bit, param[2].v32bit, (const GLvoid *)param[3].ptr);
}

void STUB_glSecondaryColorPointerEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glSecondaryColorPointerEXT( GLint, GLenum, GLsizei, const GLvoid * )
    maxParam = 4;
    char buffer0[16*4096];
    READ_PARAM(v32bit,0);
    READ_ENUM_PARAM(1);
    READ_PARAM(v32bit,2);
    READ_ARRAY_PARAM( 3, buffer0, TraceReader::TEXT_IGNORE);
    TR.skipLine();
    CHECK_USER_CALL(glSecondaryColorPointerEXT)
        UCT.glSecondaryColorPointerEXT(param[0].v32bit, param[1].uv32bit, param[2].v32bit, (const GLvoid *)param[3].ptr);
    CHECK_GL_CALL(glSecondaryColorPointerEXT)
        JT.glSecondaryColorPointerEXT(param[0].v32bit, param[1].uv32bit, param[2].v32bit, (const GLvoid *)param[3].ptr);
}

void STUB_glSelectBuffer( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glSelectBuffer( GLsizei size, GLuint *buffer )
    maxParam = 2;
    char buffer0[16*4096];
    READ_PARAM(v32bit,0);
    READ_ARRAY_PARAM( 1, buffer0, TraceReader::TEXT_INT);
    TR.skipLine();
    CHECK_USER_CALL(glSelectBuffer)
        UCT.glSelectBuffer(param[0].v32bit, (GLuint *)param[1].ptr);
    CHECK_GL_CALL(glSelectBuffer)
        JT.glSelectBuffer(param[0].v32bit, (GLuint *)param[1].ptr);
}

void STUB_glSelectPerfMonitorCountersAMD( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glSelectPerfMonitorCountersAMD( GLuint, GLboolean, GLuint, GLint, GLuint * )
    maxParam = 5;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_BOOLEAN_PARAM(1);
    READ_ENUM_PARAM(2);
    READ_PARAM(v32bit,3);
    READ_ARRAY_PARAM( 4, buffer0, TraceReader::TEXT_INT);
    TR.skipLine();
    CHECK_USER_CALL(glSelectPerfMonitorCountersAMD)
        UCT.glSelectPerfMonitorCountersAMD(param[0].uv32bit, param[1].boolean, param[2].uv32bit, param[3].v32bit, (GLuint *)param[4].ptr);
    CHECK_GL_CALL(glSelectPerfMonitorCountersAMD)
        JT.glSelectPerfMonitorCountersAMD(param[0].uv32bit, param[1].boolean, param[2].uv32bit, param[3].v32bit, (GLuint *)param[4].ptr);
}

void STUB_glSeparableFilter2D( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glSeparableFilter2D( GLenum target, GLenum internalformat, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *row, const GLvoid *column )
    maxParam = 8;
    char buffer0[16*4096];
    char buffer1[16*4096];
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_PARAM(v32bit,2);
    READ_PARAM(v32bit,3);
    READ_ENUM_PARAM(4);
    READ_ENUM_PARAM(5);
    READ_ARRAY_PARAM( 6, buffer0, TraceReader::TEXT_IGNORE);
    READ_ARRAY_PARAM( 7, buffer1, TraceReader::TEXT_IGNORE);
    TR.skipLine();
    CHECK_USER_CALL(glSeparableFilter2D)
        UCT.glSeparableFilter2D(param[0].uv32bit, param[1].uv32bit, param[2].v32bit, param[3].v32bit, param[4].uv32bit, param[5].uv32bit, (const GLvoid *)param[6].ptr, (const GLvoid *)param[7].ptr);
    CHECK_GL_CALL(glSeparableFilter2D)
        JT.glSeparableFilter2D(param[0].uv32bit, param[1].uv32bit, param[2].v32bit, param[3].v32bit, param[4].uv32bit, param[5].uv32bit, (const GLvoid *)param[6].ptr, (const GLvoid *)param[7].ptr);
}

void STUB_glSeparableFilter2DEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glSeparableFilter2DEXT( GLenum, GLenum, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *, const GLvoid * )
    maxParam = 8;
    char buffer0[16*4096];
    char buffer1[16*4096];
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_PARAM(v32bit,2);
    READ_PARAM(v32bit,3);
    READ_ENUM_PARAM(4);
    READ_ENUM_PARAM(5);
    READ_ARRAY_PARAM( 6, buffer0, TraceReader::TEXT_IGNORE);
    READ_ARRAY_PARAM( 7, buffer1, TraceReader::TEXT_IGNORE);
    TR.skipLine();
    CHECK_USER_CALL(glSeparableFilter2DEXT)
        UCT.glSeparableFilter2DEXT(param[0].uv32bit, param[1].uv32bit, param[2].v32bit, param[3].v32bit, param[4].uv32bit, param[5].uv32bit, (const GLvoid *)param[6].ptr, (const GLvoid *)param[7].ptr);
    CHECK_GL_CALL(glSeparableFilter2DEXT)
        JT.glSeparableFilter2DEXT(param[0].uv32bit, param[1].uv32bit, param[2].v32bit, param[3].v32bit, param[4].uv32bit, param[5].uv32bit, (const GLvoid *)param[6].ptr, (const GLvoid *)param[7].ptr);
}

void STUB_glSetFenceAPPLE( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glSetFenceAPPLE( GLuint )
    maxParam = 1;
    READ_ENUM_PARAM(0);
    TR.skipLine();
    CHECK_USER_CALL(glSetFenceAPPLE)
        UCT.glSetFenceAPPLE(param[0].uv32bit);
    CHECK_GL_CALL(glSetFenceAPPLE)
        JT.glSetFenceAPPLE(param[0].uv32bit);
}

void STUB_glSetFenceNV( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glSetFenceNV( GLuint, GLenum )
    maxParam = 2;
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    TR.skipLine();
    CHECK_USER_CALL(glSetFenceNV)
        UCT.glSetFenceNV(param[0].uv32bit, param[1].uv32bit);
    CHECK_GL_CALL(glSetFenceNV)
        JT.glSetFenceNV(param[0].uv32bit, param[1].uv32bit);
}

void STUB_glSetFragmentShaderConstantATI( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glSetFragmentShaderConstantATI( GLuint, const GLfloat * )
    maxParam = 2;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ARRAY_PARAM( 1, buffer0, TraceReader::TEXT_FLOAT);
    TR.skipLine();
    CHECK_USER_CALL(glSetFragmentShaderConstantATI)
        UCT.glSetFragmentShaderConstantATI(param[0].uv32bit, (const GLfloat *)param[1].ptr);
    CHECK_GL_CALL(glSetFragmentShaderConstantATI)
        JT.glSetFragmentShaderConstantATI(param[0].uv32bit, (const GLfloat *)param[1].ptr);
}

void STUB_glSetInvariantEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glSetInvariantEXT( GLuint, GLenum, const GLvoid * )
    maxParam = 3;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_ARRAY_PARAM( 2, buffer0, TraceReader::TEXT_IGNORE);
    TR.skipLine();
    CHECK_USER_CALL(glSetInvariantEXT)
        UCT.glSetInvariantEXT(param[0].uv32bit, param[1].uv32bit, (const GLvoid *)param[2].ptr);
    CHECK_GL_CALL(glSetInvariantEXT)
        JT.glSetInvariantEXT(param[0].uv32bit, param[1].uv32bit, (const GLvoid *)param[2].ptr);
}

void STUB_glSetLocalConstantEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glSetLocalConstantEXT( GLuint, GLenum, const GLvoid * )
    maxParam = 3;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_ARRAY_PARAM( 2, buffer0, TraceReader::TEXT_IGNORE);
    TR.skipLine();
    CHECK_USER_CALL(glSetLocalConstantEXT)
        UCT.glSetLocalConstantEXT(param[0].uv32bit, param[1].uv32bit, (const GLvoid *)param[2].ptr);
    CHECK_GL_CALL(glSetLocalConstantEXT)
        JT.glSetLocalConstantEXT(param[0].uv32bit, param[1].uv32bit, (const GLvoid *)param[2].ptr);
}

void STUB_glShadeModel( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glShadeModel( GLenum mode )
    maxParam = 1;
    READ_ENUM_PARAM(0);
    TR.skipLine();
    CHECK_USER_CALL(glShadeModel)
        UCT.glShadeModel(param[0].uv32bit);
    CHECK_GL_CALL(glShadeModel)
        JT.glShadeModel(param[0].uv32bit);
}

void STUB_glShaderOp1EXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glShaderOp1EXT( GLenum, GLuint, GLuint )
    maxParam = 3;
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_ENUM_PARAM(2);
    TR.skipLine();
    CHECK_USER_CALL(glShaderOp1EXT)
        UCT.glShaderOp1EXT(param[0].uv32bit, param[1].uv32bit, param[2].uv32bit);
    CHECK_GL_CALL(glShaderOp1EXT)
        JT.glShaderOp1EXT(param[0].uv32bit, param[1].uv32bit, param[2].uv32bit);
}

void STUB_glShaderOp2EXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glShaderOp2EXT( GLenum, GLuint, GLuint, GLuint )
    maxParam = 4;
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_ENUM_PARAM(2);
    READ_ENUM_PARAM(3);
    TR.skipLine();
    CHECK_USER_CALL(glShaderOp2EXT)
        UCT.glShaderOp2EXT(param[0].uv32bit, param[1].uv32bit, param[2].uv32bit, param[3].uv32bit);
    CHECK_GL_CALL(glShaderOp2EXT)
        JT.glShaderOp2EXT(param[0].uv32bit, param[1].uv32bit, param[2].uv32bit, param[3].uv32bit);
}

void STUB_glShaderOp3EXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glShaderOp3EXT( GLenum, GLuint, GLuint, GLuint, GLuint )
    maxParam = 5;
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_ENUM_PARAM(2);
    READ_ENUM_PARAM(3);
    READ_ENUM_PARAM(4);
    TR.skipLine();
    CHECK_USER_CALL(glShaderOp3EXT)
        UCT.glShaderOp3EXT(param[0].uv32bit, param[1].uv32bit, param[2].uv32bit, param[3].uv32bit, param[4].uv32bit);
    CHECK_GL_CALL(glShaderOp3EXT)
        JT.glShaderOp3EXT(param[0].uv32bit, param[1].uv32bit, param[2].uv32bit, param[3].uv32bit, param[4].uv32bit);
}

void STUB_glShaderSource( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glShaderSource( GLuint, GLsizei, const GLchar **, const GLint * )
    // Call not playable
    TR.skipCall();
}

void STUB_glShaderSourceARB( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glShaderSourceARB( GLhandleARB, GLsizei, const GLcharARB **, const GLint * )
    maxParam = 4;
    char buffer0[16*4096];
    char buffer1[16*4096];
    READ_ENUM_PARAM(0);
    READ_PARAM(v32bit,1);
    READ_ARRAY_PARAM( 2, buffer0, TraceReader::TEXT_BYTE);
    READ_ARRAY_PARAM( 3, buffer1, TraceReader::TEXT_INT);
    TR.skipLine();
    CHECK_USER_CALL(glShaderSourceARB)
        UCT.glShaderSourceARB(param[0].uv32bit, param[1].v32bit, (const GLcharARB **)param[2].ptr, (const GLint *)param[3].ptr);
    CHECK_GL_CALL(glShaderSourceARB)
        JT.glShaderSourceARB(param[0].uv32bit, param[1].v32bit, (const GLcharARB **)param[2].ptr, (const GLint *)param[3].ptr);
}

void STUB_glSharpenTexFuncSGIS( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glSharpenTexFuncSGIS( GLenum, GLsizei, const GLfloat * )
    maxParam = 3;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_PARAM(v32bit,1);
    READ_ARRAY_PARAM( 2, buffer0, TraceReader::TEXT_FLOAT);
    TR.skipLine();
    CHECK_USER_CALL(glSharpenTexFuncSGIS)
        UCT.glSharpenTexFuncSGIS(param[0].uv32bit, param[1].v32bit, (const GLfloat *)param[2].ptr);
    CHECK_GL_CALL(glSharpenTexFuncSGIS)
        JT.glSharpenTexFuncSGIS(param[0].uv32bit, param[1].v32bit, (const GLfloat *)param[2].ptr);
}

void STUB_glSpriteParameterfSGIX( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glSpriteParameterfSGIX( GLenum, GLfloat )
    maxParam = 2;
    READ_ENUM_PARAM(0);
    READ_PARAM(fv32bit,1);
    TR.skipLine();
    CHECK_USER_CALL(glSpriteParameterfSGIX)
        UCT.glSpriteParameterfSGIX(param[0].uv32bit, param[1].fv32bit);
    CHECK_GL_CALL(glSpriteParameterfSGIX)
        JT.glSpriteParameterfSGIX(param[0].uv32bit, param[1].fv32bit);
}

void STUB_glSpriteParameterfvSGIX( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glSpriteParameterfvSGIX( GLenum, const GLfloat * )
    maxParam = 2;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ARRAY_PARAM( 1, buffer0, TraceReader::TEXT_FLOAT);
    TR.skipLine();
    CHECK_USER_CALL(glSpriteParameterfvSGIX)
        UCT.glSpriteParameterfvSGIX(param[0].uv32bit, (const GLfloat *)param[1].ptr);
    CHECK_GL_CALL(glSpriteParameterfvSGIX)
        JT.glSpriteParameterfvSGIX(param[0].uv32bit, (const GLfloat *)param[1].ptr);
}

void STUB_glSpriteParameteriSGIX( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glSpriteParameteriSGIX( GLenum, GLint )
    maxParam = 2;
    READ_ENUM_PARAM(0);
    READ_PARAM(v32bit,1);
    TR.skipLine();
    CHECK_USER_CALL(glSpriteParameteriSGIX)
        UCT.glSpriteParameteriSGIX(param[0].uv32bit, param[1].v32bit);
    CHECK_GL_CALL(glSpriteParameteriSGIX)
        JT.glSpriteParameteriSGIX(param[0].uv32bit, param[1].v32bit);
}

void STUB_glSpriteParameterivSGIX( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glSpriteParameterivSGIX( GLenum, const GLint * )
    maxParam = 2;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ARRAY_PARAM( 1, buffer0, TraceReader::TEXT_INT);
    TR.skipLine();
    CHECK_USER_CALL(glSpriteParameterivSGIX)
        UCT.glSpriteParameterivSGIX(param[0].uv32bit, (const GLint *)param[1].ptr);
    CHECK_GL_CALL(glSpriteParameterivSGIX)
        JT.glSpriteParameterivSGIX(param[0].uv32bit, (const GLint *)param[1].ptr);
}

void STUB_glStartInstrumentsSGIX( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glStartInstrumentsSGIX(  )
    maxParam = 0;
    TR.skipLine();
    CHECK_USER_CALL(glStartInstrumentsSGIX)
        UCT.glStartInstrumentsSGIX();
    CHECK_GL_CALL(glStartInstrumentsSGIX)
        JT.glStartInstrumentsSGIX();
}

void STUB_glStencilClearTagEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glStencilClearTagEXT( GLsizei, GLuint )
    maxParam = 2;
    READ_PARAM(v32bit,0);
    READ_ENUM_PARAM(1);
    TR.skipLine();
    CHECK_USER_CALL(glStencilClearTagEXT)
        UCT.glStencilClearTagEXT(param[0].v32bit, param[1].uv32bit);
    CHECK_GL_CALL(glStencilClearTagEXT)
        JT.glStencilClearTagEXT(param[0].v32bit, param[1].uv32bit);
}

void STUB_glStencilFunc( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glStencilFunc( GLenum func, GLint ref, GLuint mask )
    maxParam = 3;
    READ_ENUM_PARAM(0);
    READ_PARAM(v32bit,1);
    READ_ENUM_PARAM(2);
    TR.skipLine();
    CHECK_USER_CALL(glStencilFunc)
        UCT.glStencilFunc(param[0].uv32bit, param[1].v32bit, param[2].uv32bit);
    CHECK_GL_CALL(glStencilFunc)
        JT.glStencilFunc(param[0].uv32bit, param[1].v32bit, param[2].uv32bit);
}

void STUB_glStencilFuncSeparate( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glStencilFuncSeparate( GLenum, GLenum, GLint, GLuint )
    maxParam = 4;
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_PARAM(v32bit,2);
    READ_ENUM_PARAM(3);
    TR.skipLine();
    CHECK_USER_CALL(glStencilFuncSeparate)
        UCT.glStencilFuncSeparate(param[0].uv32bit, param[1].uv32bit, param[2].v32bit, param[3].uv32bit);
    CHECK_GL_CALL(glStencilFuncSeparate)
        JT.glStencilFuncSeparate(param[0].uv32bit, param[1].uv32bit, param[2].v32bit, param[3].uv32bit);
}

void STUB_glStencilFuncSeparateATI( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glStencilFuncSeparateATI( GLenum, GLenum, GLint, GLuint )
    maxParam = 4;
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_PARAM(v32bit,2);
    READ_ENUM_PARAM(3);
    TR.skipLine();
    CHECK_USER_CALL(glStencilFuncSeparateATI)
        UCT.glStencilFuncSeparateATI(param[0].uv32bit, param[1].uv32bit, param[2].v32bit, param[3].uv32bit);
    CHECK_GL_CALL(glStencilFuncSeparateATI)
        JT.glStencilFuncSeparateATI(param[0].uv32bit, param[1].uv32bit, param[2].v32bit, param[3].uv32bit);
}

void STUB_glStencilMask( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glStencilMask( GLuint mask )
    maxParam = 1;
    READ_ENUM_PARAM(0);
    TR.skipLine();
    CHECK_USER_CALL(glStencilMask)
        UCT.glStencilMask(param[0].uv32bit);
    CHECK_GL_CALL(glStencilMask)
        JT.glStencilMask(param[0].uv32bit);
}

void STUB_glStencilMaskSeparate( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glStencilMaskSeparate( GLenum, GLuint )
    maxParam = 2;
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    TR.skipLine();
    CHECK_USER_CALL(glStencilMaskSeparate)
        UCT.glStencilMaskSeparate(param[0].uv32bit, param[1].uv32bit);
    CHECK_GL_CALL(glStencilMaskSeparate)
        JT.glStencilMaskSeparate(param[0].uv32bit, param[1].uv32bit);
}

void STUB_glStencilOp( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glStencilOp( GLenum fail, GLenum zfail, GLenum zpass )
    maxParam = 3;
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_ENUM_PARAM(2);
    TR.skipLine();
    CHECK_USER_CALL(glStencilOp)
        UCT.glStencilOp(param[0].uv32bit, param[1].uv32bit, param[2].uv32bit);
    CHECK_GL_CALL(glStencilOp)
        JT.glStencilOp(param[0].uv32bit, param[1].uv32bit, param[2].uv32bit);
}

void STUB_glStencilOpSeparate( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glStencilOpSeparate( GLenum, GLenum, GLenum, GLenum )
    maxParam = 4;
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_ENUM_PARAM(2);
    READ_ENUM_PARAM(3);
    TR.skipLine();
    CHECK_USER_CALL(glStencilOpSeparate)
        UCT.glStencilOpSeparate(param[0].uv32bit, param[1].uv32bit, param[2].uv32bit, param[3].uv32bit);
    CHECK_GL_CALL(glStencilOpSeparate)
        JT.glStencilOpSeparate(param[0].uv32bit, param[1].uv32bit, param[2].uv32bit, param[3].uv32bit);
}

void STUB_glStencilOpSeparateATI( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glStencilOpSeparateATI( GLenum, GLenum, GLenum, GLenum )
    maxParam = 4;
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_ENUM_PARAM(2);
    READ_ENUM_PARAM(3);
    TR.skipLine();
    CHECK_USER_CALL(glStencilOpSeparateATI)
        UCT.glStencilOpSeparateATI(param[0].uv32bit, param[1].uv32bit, param[2].uv32bit, param[3].uv32bit);
    CHECK_GL_CALL(glStencilOpSeparateATI)
        JT.glStencilOpSeparateATI(param[0].uv32bit, param[1].uv32bit, param[2].uv32bit, param[3].uv32bit);
}

void STUB_glStopInstrumentsSGIX( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glStopInstrumentsSGIX( GLint )
    maxParam = 1;
    READ_PARAM(v32bit,0);
    TR.skipLine();
    CHECK_USER_CALL(glStopInstrumentsSGIX)
        UCT.glStopInstrumentsSGIX(param[0].v32bit);
    CHECK_GL_CALL(glStopInstrumentsSGIX)
        JT.glStopInstrumentsSGIX(param[0].v32bit);
}

void STUB_glStringMarkerGREMEDY( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glStringMarkerGREMEDY( GLsizei, const GLvoid * )
    maxParam = 2;
    char buffer0[16*4096];
    READ_PARAM(v32bit,0);
    READ_ARRAY_PARAM( 1, buffer0, TraceReader::TEXT_IGNORE);
    TR.skipLine();
    CHECK_USER_CALL(glStringMarkerGREMEDY)
        UCT.glStringMarkerGREMEDY(param[0].v32bit, (const GLvoid *)param[1].ptr);
    CHECK_GL_CALL(glStringMarkerGREMEDY)
        JT.glStringMarkerGREMEDY(param[0].v32bit, (const GLvoid *)param[1].ptr);
}

void STUB_glSwizzleEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glSwizzleEXT( GLuint, GLuint, GLenum, GLenum, GLenum, GLenum )
    maxParam = 6;
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_ENUM_PARAM(2);
    READ_ENUM_PARAM(3);
    READ_ENUM_PARAM(4);
    READ_ENUM_PARAM(5);
    TR.skipLine();
    CHECK_USER_CALL(glSwizzleEXT)
        UCT.glSwizzleEXT(param[0].uv32bit, param[1].uv32bit, param[2].uv32bit, param[3].uv32bit, param[4].uv32bit, param[5].uv32bit);
    CHECK_GL_CALL(glSwizzleEXT)
        JT.glSwizzleEXT(param[0].uv32bit, param[1].uv32bit, param[2].uv32bit, param[3].uv32bit, param[4].uv32bit, param[5].uv32bit);
}

void STUB_glTagSampleBufferSGIX( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glTagSampleBufferSGIX(  )
    maxParam = 0;
    TR.skipLine();
    CHECK_USER_CALL(glTagSampleBufferSGIX)
        UCT.glTagSampleBufferSGIX();
    CHECK_GL_CALL(glTagSampleBufferSGIX)
        JT.glTagSampleBufferSGIX();
}

void STUB_glTangent3bEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glTangent3bEXT( GLbyte, GLbyte, GLbyte )
    maxParam = 3;
    READ_PARAM(v8bit,0);
    READ_PARAM(v8bit,1);
    READ_PARAM(v8bit,2);
    TR.skipLine();
    CHECK_USER_CALL(glTangent3bEXT)
        UCT.glTangent3bEXT(param[0].v8bit, param[1].v8bit, param[2].v8bit);
    CHECK_GL_CALL(glTangent3bEXT)
        JT.glTangent3bEXT(param[0].v8bit, param[1].v8bit, param[2].v8bit);
}

void STUB_glTangent3bvEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glTangent3bvEXT( const GLbyte * )
    maxParam = 1;
    char buffer0[16*4096];
    READ_ARRAY_PARAM( 0, buffer0, TraceReader::TEXT_BYTE);
    TR.skipLine();
    CHECK_USER_CALL(glTangent3bvEXT)
        UCT.glTangent3bvEXT((const GLbyte *)param[0].ptr);
    CHECK_GL_CALL(glTangent3bvEXT)
        JT.glTangent3bvEXT((const GLbyte *)param[0].ptr);
}

void STUB_glTangent3dEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glTangent3dEXT( GLdouble, GLdouble, GLdouble )
    maxParam = 3;
    READ_DOUBLE_PARAM(0);
    READ_DOUBLE_PARAM(1);
    READ_DOUBLE_PARAM(2);
    TR.skipLine();
    CHECK_USER_CALL(glTangent3dEXT)
        UCT.glTangent3dEXT(param[0].fv64bit, param[1].fv64bit, param[2].fv64bit);
    CHECK_GL_CALL(glTangent3dEXT)
        JT.glTangent3dEXT(param[0].fv64bit, param[1].fv64bit, param[2].fv64bit);
}

void STUB_glTangent3dvEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glTangent3dvEXT( const GLdouble * )
    maxParam = 1;
    char buffer0[16*4096];
    READ_ARRAY_PARAM( 0, buffer0, TraceReader::TEXT_DOUBLE);
    TR.skipLine();
    CHECK_USER_CALL(glTangent3dvEXT)
        UCT.glTangent3dvEXT((const GLdouble *)param[0].ptr);
    CHECK_GL_CALL(glTangent3dvEXT)
        JT.glTangent3dvEXT((const GLdouble *)param[0].ptr);
}

void STUB_glTangent3fEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glTangent3fEXT( GLfloat, GLfloat, GLfloat )
    maxParam = 3;
    READ_PARAM(fv32bit,0);
    READ_PARAM(fv32bit,1);
    READ_PARAM(fv32bit,2);
    TR.skipLine();
    CHECK_USER_CALL(glTangent3fEXT)
        UCT.glTangent3fEXT(param[0].fv32bit, param[1].fv32bit, param[2].fv32bit);
    CHECK_GL_CALL(glTangent3fEXT)
        JT.glTangent3fEXT(param[0].fv32bit, param[1].fv32bit, param[2].fv32bit);
}

void STUB_glTangent3fvEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glTangent3fvEXT( const GLfloat * )
    maxParam = 1;
    char buffer0[16*4096];
    READ_ARRAY_PARAM( 0, buffer0, TraceReader::TEXT_FLOAT);
    TR.skipLine();
    CHECK_USER_CALL(glTangent3fvEXT)
        UCT.glTangent3fvEXT((const GLfloat *)param[0].ptr);
    CHECK_GL_CALL(glTangent3fvEXT)
        JT.glTangent3fvEXT((const GLfloat *)param[0].ptr);
}

void STUB_glTangent3iEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glTangent3iEXT( GLint, GLint, GLint )
    maxParam = 3;
    READ_PARAM(v32bit,0);
    READ_PARAM(v32bit,1);
    READ_PARAM(v32bit,2);
    TR.skipLine();
    CHECK_USER_CALL(glTangent3iEXT)
        UCT.glTangent3iEXT(param[0].v32bit, param[1].v32bit, param[2].v32bit);
    CHECK_GL_CALL(glTangent3iEXT)
        JT.glTangent3iEXT(param[0].v32bit, param[1].v32bit, param[2].v32bit);
}

void STUB_glTangent3ivEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glTangent3ivEXT( const GLint * )
    maxParam = 1;
    char buffer0[16*4096];
    READ_ARRAY_PARAM( 0, buffer0, TraceReader::TEXT_INT);
    TR.skipLine();
    CHECK_USER_CALL(glTangent3ivEXT)
        UCT.glTangent3ivEXT((const GLint *)param[0].ptr);
    CHECK_GL_CALL(glTangent3ivEXT)
        JT.glTangent3ivEXT((const GLint *)param[0].ptr);
}

void STUB_glTangent3sEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glTangent3sEXT( GLshort, GLshort, GLshort )
    maxParam = 3;
    READ_PARAM(v16bit,0);
    READ_PARAM(v16bit,1);
    READ_PARAM(v16bit,2);
    TR.skipLine();
    CHECK_USER_CALL(glTangent3sEXT)
        UCT.glTangent3sEXT(param[0].v16bit, param[1].v16bit, param[2].v16bit);
    CHECK_GL_CALL(glTangent3sEXT)
        JT.glTangent3sEXT(param[0].v16bit, param[1].v16bit, param[2].v16bit);
}

void STUB_glTangent3svEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glTangent3svEXT( const GLshort * )
    maxParam = 1;
    char buffer0[16*4096];
    READ_ARRAY_PARAM( 0, buffer0, TraceReader::TEXT_SHORT);
    TR.skipLine();
    CHECK_USER_CALL(glTangent3svEXT)
        UCT.glTangent3svEXT((const GLshort *)param[0].ptr);
    CHECK_GL_CALL(glTangent3svEXT)
        JT.glTangent3svEXT((const GLshort *)param[0].ptr);
}

void STUB_glTangentPointerEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glTangentPointerEXT( GLenum, GLsizei, const GLvoid * )
    maxParam = 3;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_PARAM(v32bit,1);
    READ_ARRAY_PARAM( 2, buffer0, TraceReader::TEXT_IGNORE);
    TR.skipLine();
    CHECK_USER_CALL(glTangentPointerEXT)
        UCT.glTangentPointerEXT(param[0].uv32bit, param[1].v32bit, (const GLvoid *)param[2].ptr);
    CHECK_GL_CALL(glTangentPointerEXT)
        JT.glTangentPointerEXT(param[0].uv32bit, param[1].v32bit, (const GLvoid *)param[2].ptr);
}

void STUB_glTbufferMask3DFX( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glTbufferMask3DFX( GLuint )
    maxParam = 1;
    READ_ENUM_PARAM(0);
    TR.skipLine();
    CHECK_USER_CALL(glTbufferMask3DFX)
        UCT.glTbufferMask3DFX(param[0].uv32bit);
    CHECK_GL_CALL(glTbufferMask3DFX)
        JT.glTbufferMask3DFX(param[0].uv32bit);
}

void STUB_glTessellationFactorAMD( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glTessellationFactorAMD( GLfloat )
    maxParam = 1;
    READ_PARAM(fv32bit,0);
    TR.skipLine();
    CHECK_USER_CALL(glTessellationFactorAMD)
        UCT.glTessellationFactorAMD(param[0].fv32bit);
    CHECK_GL_CALL(glTessellationFactorAMD)
        JT.glTessellationFactorAMD(param[0].fv32bit);
}

void STUB_glTessellationModeAMD( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glTessellationModeAMD( GLenum )
    maxParam = 1;
    READ_ENUM_PARAM(0);
    TR.skipLine();
    CHECK_USER_CALL(glTessellationModeAMD)
        UCT.glTessellationModeAMD(param[0].uv32bit);
    CHECK_GL_CALL(glTessellationModeAMD)
        JT.glTessellationModeAMD(param[0].uv32bit);
}

void STUB_glTestFenceAPPLE( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // GLboolean glTestFenceAPPLE( GLuint )
    maxParam = 1;
    READ_ENUM_PARAM(0);
    TR.skipResult();
    TR.skipLine();
    CHECK_USER_CALL(glTestFenceAPPLE)
        UCT.glTestFenceAPPLE(param[0].uv32bit);
    CHECK_GL_CALL(glTestFenceAPPLE)
        JT.glTestFenceAPPLE(param[0].uv32bit);
}

void STUB_glTestFenceNV( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // GLboolean glTestFenceNV( GLuint )
    maxParam = 1;
    READ_ENUM_PARAM(0);
    TR.skipResult();
    TR.skipLine();
    CHECK_USER_CALL(glTestFenceNV)
        UCT.glTestFenceNV(param[0].uv32bit);
    CHECK_GL_CALL(glTestFenceNV)
        JT.glTestFenceNV(param[0].uv32bit);
}

void STUB_glTestObjectAPPLE( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // GLboolean glTestObjectAPPLE( GLenum, GLuint )
    maxParam = 2;
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    TR.skipResult();
    TR.skipLine();
    CHECK_USER_CALL(glTestObjectAPPLE)
        UCT.glTestObjectAPPLE(param[0].uv32bit, param[1].uv32bit);
    CHECK_GL_CALL(glTestObjectAPPLE)
        JT.glTestObjectAPPLE(param[0].uv32bit, param[1].uv32bit);
}

void STUB_glTexBuffer( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glTexBuffer( GLenum, GLenum, GLuint )
    maxParam = 3;
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_ENUM_PARAM(2);
    TR.skipLine();
    CHECK_USER_CALL(glTexBuffer)
        UCT.glTexBuffer(param[0].uv32bit, param[1].uv32bit, param[2].uv32bit);
    CHECK_GL_CALL(glTexBuffer)
        JT.glTexBuffer(param[0].uv32bit, param[1].uv32bit, param[2].uv32bit);
}

void STUB_glTexBufferARB( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glTexBufferARB( GLenum, GLenum, GLuint )
    maxParam = 3;
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_ENUM_PARAM(2);
    TR.skipLine();
    CHECK_USER_CALL(glTexBufferARB)
        UCT.glTexBufferARB(param[0].uv32bit, param[1].uv32bit, param[2].uv32bit);
    CHECK_GL_CALL(glTexBufferARB)
        JT.glTexBufferARB(param[0].uv32bit, param[1].uv32bit, param[2].uv32bit);
}

void STUB_glTexBufferEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glTexBufferEXT( GLenum, GLenum, GLuint )
    maxParam = 3;
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_ENUM_PARAM(2);
    TR.skipLine();
    CHECK_USER_CALL(glTexBufferEXT)
        UCT.glTexBufferEXT(param[0].uv32bit, param[1].uv32bit, param[2].uv32bit);
    CHECK_GL_CALL(glTexBufferEXT)
        JT.glTexBufferEXT(param[0].uv32bit, param[1].uv32bit, param[2].uv32bit);
}

void STUB_glTexBumpParameterfvATI( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glTexBumpParameterfvATI( GLenum, const GLfloat * )
    maxParam = 2;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ARRAY_PARAM( 1, buffer0, TraceReader::TEXT_FLOAT);
    TR.skipLine();
    CHECK_USER_CALL(glTexBumpParameterfvATI)
        UCT.glTexBumpParameterfvATI(param[0].uv32bit, (const GLfloat *)param[1].ptr);
    CHECK_GL_CALL(glTexBumpParameterfvATI)
        JT.glTexBumpParameterfvATI(param[0].uv32bit, (const GLfloat *)param[1].ptr);
}

void STUB_glTexBumpParameterivATI( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glTexBumpParameterivATI( GLenum, const GLint * )
    maxParam = 2;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ARRAY_PARAM( 1, buffer0, TraceReader::TEXT_INT);
    TR.skipLine();
    CHECK_USER_CALL(glTexBumpParameterivATI)
        UCT.glTexBumpParameterivATI(param[0].uv32bit, (const GLint *)param[1].ptr);
    CHECK_GL_CALL(glTexBumpParameterivATI)
        JT.glTexBumpParameterivATI(param[0].uv32bit, (const GLint *)param[1].ptr);
}

void STUB_glTexCoord1d( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glTexCoord1d( GLdouble s )
    maxParam = 1;
    READ_DOUBLE_PARAM(0);
    TR.skipLine();
    CHECK_USER_CALL(glTexCoord1d)
        UCT.glTexCoord1d(param[0].fv64bit);
    CHECK_GL_CALL(glTexCoord1d)
        JT.glTexCoord1d(param[0].fv64bit);
}

void STUB_glTexCoord1dv( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glTexCoord1dv( const GLdouble *v )
    maxParam = 1;
    char buffer0[16*4096];
    READ_ARRAY_PARAM( 0, buffer0, TraceReader::TEXT_DOUBLE);
    TR.skipLine();
    CHECK_USER_CALL(glTexCoord1dv)
        UCT.glTexCoord1dv((const GLdouble *)param[0].ptr);
    CHECK_GL_CALL(glTexCoord1dv)
        JT.glTexCoord1dv((const GLdouble *)param[0].ptr);
}

void STUB_glTexCoord1f( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glTexCoord1f( GLfloat s )
    maxParam = 1;
    READ_PARAM(fv32bit,0);
    TR.skipLine();
    CHECK_USER_CALL(glTexCoord1f)
        UCT.glTexCoord1f(param[0].fv32bit);
    CHECK_GL_CALL(glTexCoord1f)
        JT.glTexCoord1f(param[0].fv32bit);
}

void STUB_glTexCoord1fv( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glTexCoord1fv( const GLfloat *v )
    maxParam = 1;
    char buffer0[16*4096];
    READ_ARRAY_PARAM( 0, buffer0, TraceReader::TEXT_FLOAT);
    TR.skipLine();
    CHECK_USER_CALL(glTexCoord1fv)
        UCT.glTexCoord1fv((const GLfloat *)param[0].ptr);
    CHECK_GL_CALL(glTexCoord1fv)
        JT.glTexCoord1fv((const GLfloat *)param[0].ptr);
}

void STUB_glTexCoord1hNV( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glTexCoord1hNV( GLhalfNV )
    // Call not playable
    TR.skipCall();
}

void STUB_glTexCoord1hvNV( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glTexCoord1hvNV( const GLhalfNV * )
    // Call not playable
    TR.skipCall();
}

void STUB_glTexCoord1i( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glTexCoord1i( GLint s )
    maxParam = 1;
    READ_PARAM(v32bit,0);
    TR.skipLine();
    CHECK_USER_CALL(glTexCoord1i)
        UCT.glTexCoord1i(param[0].v32bit);
    CHECK_GL_CALL(glTexCoord1i)
        JT.glTexCoord1i(param[0].v32bit);
}

void STUB_glTexCoord1iv( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glTexCoord1iv( const GLint *v )
    maxParam = 1;
    char buffer0[16*4096];
    READ_ARRAY_PARAM( 0, buffer0, TraceReader::TEXT_INT);
    TR.skipLine();
    CHECK_USER_CALL(glTexCoord1iv)
        UCT.glTexCoord1iv((const GLint *)param[0].ptr);
    CHECK_GL_CALL(glTexCoord1iv)
        JT.glTexCoord1iv((const GLint *)param[0].ptr);
}

void STUB_glTexCoord1s( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glTexCoord1s( GLshort s )
    maxParam = 1;
    READ_PARAM(v16bit,0);
    TR.skipLine();
    CHECK_USER_CALL(glTexCoord1s)
        UCT.glTexCoord1s(param[0].v16bit);
    CHECK_GL_CALL(glTexCoord1s)
        JT.glTexCoord1s(param[0].v16bit);
}

void STUB_glTexCoord1sv( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glTexCoord1sv( const GLshort *v )
    maxParam = 1;
    char buffer0[16*4096];
    READ_ARRAY_PARAM( 0, buffer0, TraceReader::TEXT_SHORT);
    TR.skipLine();
    CHECK_USER_CALL(glTexCoord1sv)
        UCT.glTexCoord1sv((const GLshort *)param[0].ptr);
    CHECK_GL_CALL(glTexCoord1sv)
        JT.glTexCoord1sv((const GLshort *)param[0].ptr);
}

void STUB_glTexCoord2d( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glTexCoord2d( GLdouble s, GLdouble t )
    maxParam = 2;
    READ_DOUBLE_PARAM(0);
    READ_DOUBLE_PARAM(1);
    TR.skipLine();
    CHECK_USER_CALL(glTexCoord2d)
        UCT.glTexCoord2d(param[0].fv64bit, param[1].fv64bit);
    CHECK_GL_CALL(glTexCoord2d)
        JT.glTexCoord2d(param[0].fv64bit, param[1].fv64bit);
}

void STUB_glTexCoord2dv( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glTexCoord2dv( const GLdouble *v )
    maxParam = 1;
    char buffer0[16*4096];
    READ_ARRAY_PARAM( 0, buffer0, TraceReader::TEXT_DOUBLE);
    TR.skipLine();
    CHECK_USER_CALL(glTexCoord2dv)
        UCT.glTexCoord2dv((const GLdouble *)param[0].ptr);
    CHECK_GL_CALL(glTexCoord2dv)
        JT.glTexCoord2dv((const GLdouble *)param[0].ptr);
}

void STUB_glTexCoord2f( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glTexCoord2f( GLfloat s, GLfloat t )
    maxParam = 2;
    READ_PARAM(fv32bit,0);
    READ_PARAM(fv32bit,1);
    TR.skipLine();
    CHECK_USER_CALL(glTexCoord2f)
        UCT.glTexCoord2f(param[0].fv32bit, param[1].fv32bit);
    CHECK_GL_CALL(glTexCoord2f)
        JT.glTexCoord2f(param[0].fv32bit, param[1].fv32bit);
}

void STUB_glTexCoord2fv( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glTexCoord2fv( const GLfloat *v )
    maxParam = 1;
    char buffer0[16*4096];
    READ_ARRAY_PARAM( 0, buffer0, TraceReader::TEXT_FLOAT);
    TR.skipLine();
    CHECK_USER_CALL(glTexCoord2fv)
        UCT.glTexCoord2fv((const GLfloat *)param[0].ptr);
    CHECK_GL_CALL(glTexCoord2fv)
        JT.glTexCoord2fv((const GLfloat *)param[0].ptr);
}

void STUB_glTexCoord2hNV( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glTexCoord2hNV( GLhalfNV, GLhalfNV )
    // Call not playable
    TR.skipCall();
}

void STUB_glTexCoord2hvNV( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glTexCoord2hvNV( const GLhalfNV * )
    // Call not playable
    TR.skipCall();
}

void STUB_glTexCoord2i( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glTexCoord2i( GLint s, GLint t )
    maxParam = 2;
    READ_PARAM(v32bit,0);
    READ_PARAM(v32bit,1);
    TR.skipLine();
    CHECK_USER_CALL(glTexCoord2i)
        UCT.glTexCoord2i(param[0].v32bit, param[1].v32bit);
    CHECK_GL_CALL(glTexCoord2i)
        JT.glTexCoord2i(param[0].v32bit, param[1].v32bit);
}

void STUB_glTexCoord2iv( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glTexCoord2iv( const GLint *v )
    maxParam = 1;
    char buffer0[16*4096];
    READ_ARRAY_PARAM( 0, buffer0, TraceReader::TEXT_INT);
    TR.skipLine();
    CHECK_USER_CALL(glTexCoord2iv)
        UCT.glTexCoord2iv((const GLint *)param[0].ptr);
    CHECK_GL_CALL(glTexCoord2iv)
        JT.glTexCoord2iv((const GLint *)param[0].ptr);
}

void STUB_glTexCoord2s( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glTexCoord2s( GLshort s, GLshort t )
    maxParam = 2;
    READ_PARAM(v16bit,0);
    READ_PARAM(v16bit,1);
    TR.skipLine();
    CHECK_USER_CALL(glTexCoord2s)
        UCT.glTexCoord2s(param[0].v16bit, param[1].v16bit);
    CHECK_GL_CALL(glTexCoord2s)
        JT.glTexCoord2s(param[0].v16bit, param[1].v16bit);
}

void STUB_glTexCoord2sv( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glTexCoord2sv( const GLshort *v )
    maxParam = 1;
    char buffer0[16*4096];
    READ_ARRAY_PARAM( 0, buffer0, TraceReader::TEXT_SHORT);
    TR.skipLine();
    CHECK_USER_CALL(glTexCoord2sv)
        UCT.glTexCoord2sv((const GLshort *)param[0].ptr);
    CHECK_GL_CALL(glTexCoord2sv)
        JT.glTexCoord2sv((const GLshort *)param[0].ptr);
}

void STUB_glTexCoord3d( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glTexCoord3d( GLdouble s, GLdouble t, GLdouble r )
    maxParam = 3;
    READ_DOUBLE_PARAM(0);
    READ_DOUBLE_PARAM(1);
    READ_DOUBLE_PARAM(2);
    TR.skipLine();
    CHECK_USER_CALL(glTexCoord3d)
        UCT.glTexCoord3d(param[0].fv64bit, param[1].fv64bit, param[2].fv64bit);
    CHECK_GL_CALL(glTexCoord3d)
        JT.glTexCoord3d(param[0].fv64bit, param[1].fv64bit, param[2].fv64bit);
}

void STUB_glTexCoord3dv( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glTexCoord3dv( const GLdouble *v )
    maxParam = 1;
    char buffer0[16*4096];
    READ_ARRAY_PARAM( 0, buffer0, TraceReader::TEXT_DOUBLE);
    TR.skipLine();
    CHECK_USER_CALL(glTexCoord3dv)
        UCT.glTexCoord3dv((const GLdouble *)param[0].ptr);
    CHECK_GL_CALL(glTexCoord3dv)
        JT.glTexCoord3dv((const GLdouble *)param[0].ptr);
}

void STUB_glTexCoord3f( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glTexCoord3f( GLfloat s, GLfloat t, GLfloat r )
    maxParam = 3;
    READ_PARAM(fv32bit,0);
    READ_PARAM(fv32bit,1);
    READ_PARAM(fv32bit,2);
    TR.skipLine();
    CHECK_USER_CALL(glTexCoord3f)
        UCT.glTexCoord3f(param[0].fv32bit, param[1].fv32bit, param[2].fv32bit);
    CHECK_GL_CALL(glTexCoord3f)
        JT.glTexCoord3f(param[0].fv32bit, param[1].fv32bit, param[2].fv32bit);
}

void STUB_glTexCoord3fv( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glTexCoord3fv( const GLfloat *v )
    maxParam = 1;
    char buffer0[16*4096];
    READ_ARRAY_PARAM( 0, buffer0, TraceReader::TEXT_FLOAT);
    TR.skipLine();
    CHECK_USER_CALL(glTexCoord3fv)
        UCT.glTexCoord3fv((const GLfloat *)param[0].ptr);
    CHECK_GL_CALL(glTexCoord3fv)
        JT.glTexCoord3fv((const GLfloat *)param[0].ptr);
}

void STUB_glTexCoord3hNV( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glTexCoord3hNV( GLhalfNV, GLhalfNV, GLhalfNV )
    // Call not playable
    TR.skipCall();
}

void STUB_glTexCoord3hvNV( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glTexCoord3hvNV( const GLhalfNV * )
    // Call not playable
    TR.skipCall();
}

void STUB_glTexCoord3i( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glTexCoord3i( GLint s, GLint t, GLint r )
    maxParam = 3;
    READ_PARAM(v32bit,0);
    READ_PARAM(v32bit,1);
    READ_PARAM(v32bit,2);
    TR.skipLine();
    CHECK_USER_CALL(glTexCoord3i)
        UCT.glTexCoord3i(param[0].v32bit, param[1].v32bit, param[2].v32bit);
    CHECK_GL_CALL(glTexCoord3i)
        JT.glTexCoord3i(param[0].v32bit, param[1].v32bit, param[2].v32bit);
}

void STUB_glTexCoord3iv( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glTexCoord3iv( const GLint *v )
    maxParam = 1;
    char buffer0[16*4096];
    READ_ARRAY_PARAM( 0, buffer0, TraceReader::TEXT_INT);
    TR.skipLine();
    CHECK_USER_CALL(glTexCoord3iv)
        UCT.glTexCoord3iv((const GLint *)param[0].ptr);
    CHECK_GL_CALL(glTexCoord3iv)
        JT.glTexCoord3iv((const GLint *)param[0].ptr);
}

void STUB_glTexCoord3s( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glTexCoord3s( GLshort s, GLshort t, GLshort r )
    maxParam = 3;
    READ_PARAM(v16bit,0);
    READ_PARAM(v16bit,1);
    READ_PARAM(v16bit,2);
    TR.skipLine();
    CHECK_USER_CALL(glTexCoord3s)
        UCT.glTexCoord3s(param[0].v16bit, param[1].v16bit, param[2].v16bit);
    CHECK_GL_CALL(glTexCoord3s)
        JT.glTexCoord3s(param[0].v16bit, param[1].v16bit, param[2].v16bit);
}

void STUB_glTexCoord3sv( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glTexCoord3sv( const GLshort *v )
    maxParam = 1;
    char buffer0[16*4096];
    READ_ARRAY_PARAM( 0, buffer0, TraceReader::TEXT_SHORT);
    TR.skipLine();
    CHECK_USER_CALL(glTexCoord3sv)
        UCT.glTexCoord3sv((const GLshort *)param[0].ptr);
    CHECK_GL_CALL(glTexCoord3sv)
        JT.glTexCoord3sv((const GLshort *)param[0].ptr);
}

void STUB_glTexCoord4d( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glTexCoord4d( GLdouble s, GLdouble t, GLdouble r, GLdouble q )
    maxParam = 4;
    READ_DOUBLE_PARAM(0);
    READ_DOUBLE_PARAM(1);
    READ_DOUBLE_PARAM(2);
    READ_DOUBLE_PARAM(3);
    TR.skipLine();
    CHECK_USER_CALL(glTexCoord4d)
        UCT.glTexCoord4d(param[0].fv64bit, param[1].fv64bit, param[2].fv64bit, param[3].fv64bit);
    CHECK_GL_CALL(glTexCoord4d)
        JT.glTexCoord4d(param[0].fv64bit, param[1].fv64bit, param[2].fv64bit, param[3].fv64bit);
}

void STUB_glTexCoord4dv( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glTexCoord4dv( const GLdouble *v )
    maxParam = 1;
    char buffer0[16*4096];
    READ_ARRAY_PARAM( 0, buffer0, TraceReader::TEXT_DOUBLE);
    TR.skipLine();
    CHECK_USER_CALL(glTexCoord4dv)
        UCT.glTexCoord4dv((const GLdouble *)param[0].ptr);
    CHECK_GL_CALL(glTexCoord4dv)
        JT.glTexCoord4dv((const GLdouble *)param[0].ptr);
}

void STUB_glTexCoord4f( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glTexCoord4f( GLfloat s, GLfloat t, GLfloat r, GLfloat q )
    maxParam = 4;
    READ_PARAM(fv32bit,0);
    READ_PARAM(fv32bit,1);
    READ_PARAM(fv32bit,2);
    READ_PARAM(fv32bit,3);
    TR.skipLine();
    CHECK_USER_CALL(glTexCoord4f)
        UCT.glTexCoord4f(param[0].fv32bit, param[1].fv32bit, param[2].fv32bit, param[3].fv32bit);
    CHECK_GL_CALL(glTexCoord4f)
        JT.glTexCoord4f(param[0].fv32bit, param[1].fv32bit, param[2].fv32bit, param[3].fv32bit);
}

void STUB_glTexCoord4fv( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glTexCoord4fv( const GLfloat *v )
    maxParam = 1;
    char buffer0[16*4096];
    READ_ARRAY_PARAM( 0, buffer0, TraceReader::TEXT_FLOAT);
    TR.skipLine();
    CHECK_USER_CALL(glTexCoord4fv)
        UCT.glTexCoord4fv((const GLfloat *)param[0].ptr);
    CHECK_GL_CALL(glTexCoord4fv)
        JT.glTexCoord4fv((const GLfloat *)param[0].ptr);
}

void STUB_glTexCoord4hNV( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glTexCoord4hNV( GLhalfNV, GLhalfNV, GLhalfNV, GLhalfNV )
    // Call not playable
    TR.skipCall();
}

void STUB_glTexCoord4hvNV( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glTexCoord4hvNV( const GLhalfNV * )
    // Call not playable
    TR.skipCall();
}

void STUB_glTexCoord4i( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glTexCoord4i( GLint s, GLint t, GLint r, GLint q )
    maxParam = 4;
    READ_PARAM(v32bit,0);
    READ_PARAM(v32bit,1);
    READ_PARAM(v32bit,2);
    READ_PARAM(v32bit,3);
    TR.skipLine();
    CHECK_USER_CALL(glTexCoord4i)
        UCT.glTexCoord4i(param[0].v32bit, param[1].v32bit, param[2].v32bit, param[3].v32bit);
    CHECK_GL_CALL(glTexCoord4i)
        JT.glTexCoord4i(param[0].v32bit, param[1].v32bit, param[2].v32bit, param[3].v32bit);
}

void STUB_glTexCoord4iv( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glTexCoord4iv( const GLint *v )
    maxParam = 1;
    char buffer0[16*4096];
    READ_ARRAY_PARAM( 0, buffer0, TraceReader::TEXT_INT);
    TR.skipLine();
    CHECK_USER_CALL(glTexCoord4iv)
        UCT.glTexCoord4iv((const GLint *)param[0].ptr);
    CHECK_GL_CALL(glTexCoord4iv)
        JT.glTexCoord4iv((const GLint *)param[0].ptr);
}

void STUB_glTexCoord4s( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glTexCoord4s( GLshort s, GLshort t, GLshort r, GLshort q )
    maxParam = 4;
    READ_PARAM(v16bit,0);
    READ_PARAM(v16bit,1);
    READ_PARAM(v16bit,2);
    READ_PARAM(v16bit,3);
    TR.skipLine();
    CHECK_USER_CALL(glTexCoord4s)
        UCT.glTexCoord4s(param[0].v16bit, param[1].v16bit, param[2].v16bit, param[3].v16bit);
    CHECK_GL_CALL(glTexCoord4s)
        JT.glTexCoord4s(param[0].v16bit, param[1].v16bit, param[2].v16bit, param[3].v16bit);
}

void STUB_glTexCoord4sv( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glTexCoord4sv( const GLshort *v )
    maxParam = 1;
    char buffer0[16*4096];
    READ_ARRAY_PARAM( 0, buffer0, TraceReader::TEXT_SHORT);
    TR.skipLine();
    CHECK_USER_CALL(glTexCoord4sv)
        UCT.glTexCoord4sv((const GLshort *)param[0].ptr);
    CHECK_GL_CALL(glTexCoord4sv)
        JT.glTexCoord4sv((const GLshort *)param[0].ptr);
}

void STUB_glTexCoordPointer( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glTexCoordPointer( GLint size, GLenum type, GLsizei stride, const GLvoid *ptr )
    maxParam = 4;
    char buffer0[16*4096];
    READ_PARAM(v32bit,0);
    READ_ENUM_PARAM(1);
    READ_PARAM(v32bit,2);
    READ_ARRAY_PARAM( 3, buffer0, TraceReader::TEXT_IGNORE);
    TR.skipLine();
    CHECK_USER_CALL(glTexCoordPointer)
        UCT.glTexCoordPointer(param[0].v32bit, param[1].uv32bit, param[2].v32bit, (const GLvoid *)param[3].ptr);
    CHECK_GL_CALL(glTexCoordPointer)
        JT.glTexCoordPointer(param[0].v32bit, param[1].uv32bit, param[2].v32bit, (const GLvoid *)param[3].ptr);
}

void STUB_glTexCoordPointerEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glTexCoordPointerEXT( GLint, GLenum, GLsizei, GLsizei, const GLvoid * )
    maxParam = 5;
    char buffer0[16*4096];
    READ_PARAM(v32bit,0);
    READ_ENUM_PARAM(1);
    READ_PARAM(v32bit,2);
    READ_PARAM(v32bit,3);
    READ_ARRAY_PARAM( 4, buffer0, TraceReader::TEXT_IGNORE);
    TR.skipLine();
    CHECK_USER_CALL(glTexCoordPointerEXT)
        UCT.glTexCoordPointerEXT(param[0].v32bit, param[1].uv32bit, param[2].v32bit, param[3].v32bit, (const GLvoid *)param[4].ptr);
    CHECK_GL_CALL(glTexCoordPointerEXT)
        JT.glTexCoordPointerEXT(param[0].v32bit, param[1].uv32bit, param[2].v32bit, param[3].v32bit, (const GLvoid *)param[4].ptr);
}

void STUB_glTexCoordPointervINTEL( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glTexCoordPointervINTEL( GLint, GLenum, const GLvoid ** )
    maxParam = 3;
    char buffer0[16*4096];
    READ_PARAM(v32bit,0);
    READ_ENUM_PARAM(1);
    READ_ARRAY_PARAM( 2, buffer0, TraceReader::TEXT_IGNORE);
    TR.skipLine();
    CHECK_USER_CALL(glTexCoordPointervINTEL)
        UCT.glTexCoordPointervINTEL(param[0].v32bit, param[1].uv32bit, (const GLvoid **)param[2].ptr);
    CHECK_GL_CALL(glTexCoordPointervINTEL)
        JT.glTexCoordPointervINTEL(param[0].v32bit, param[1].uv32bit, (const GLvoid **)param[2].ptr);
}

void STUB_glTexEnvf( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glTexEnvf( GLenum target, GLenum pname, GLfloat param )
    maxParam = 3;
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_PARAM(fv32bit,2);
    TR.skipLine();
    CHECK_USER_CALL(glTexEnvf)
        UCT.glTexEnvf(param[0].uv32bit, param[1].uv32bit, param[2].fv32bit);
    CHECK_GL_CALL(glTexEnvf)
        JT.glTexEnvf(param[0].uv32bit, param[1].uv32bit, param[2].fv32bit);
}

void STUB_glTexEnvfv( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glTexEnvfv( GLenum target, GLenum pname, const GLfloat *params )
    maxParam = 3;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_ARRAY_PARAM( 2, buffer0, TraceReader::TEXT_FLOAT);
    TR.skipLine();
    CHECK_USER_CALL(glTexEnvfv)
        UCT.glTexEnvfv(param[0].uv32bit, param[1].uv32bit, (const GLfloat *)param[2].ptr);
    CHECK_GL_CALL(glTexEnvfv)
        JT.glTexEnvfv(param[0].uv32bit, param[1].uv32bit, (const GLfloat *)param[2].ptr);
}

void STUB_glTexEnvi( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glTexEnvi( GLenum target, GLenum pname, GLint param )
    maxParam = 3;
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_PARAM(v32bit,2);
    TR.skipLine();
    CHECK_USER_CALL(glTexEnvi)
        UCT.glTexEnvi(param[0].uv32bit, param[1].uv32bit, param[2].v32bit);
    CHECK_GL_CALL(glTexEnvi)
        JT.glTexEnvi(param[0].uv32bit, param[1].uv32bit, param[2].v32bit);
}

void STUB_glTexEnviv( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glTexEnviv( GLenum target, GLenum pname, const GLint *params )
    maxParam = 3;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_ARRAY_PARAM( 2, buffer0, TraceReader::TEXT_INT);
    TR.skipLine();
    CHECK_USER_CALL(glTexEnviv)
        UCT.glTexEnviv(param[0].uv32bit, param[1].uv32bit, (const GLint *)param[2].ptr);
    CHECK_GL_CALL(glTexEnviv)
        JT.glTexEnviv(param[0].uv32bit, param[1].uv32bit, (const GLint *)param[2].ptr);
}

void STUB_glTexFilterFuncSGIS( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glTexFilterFuncSGIS( GLenum, GLenum, GLsizei, const GLfloat * )
    maxParam = 4;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_PARAM(v32bit,2);
    READ_ARRAY_PARAM( 3, buffer0, TraceReader::TEXT_FLOAT);
    TR.skipLine();
    CHECK_USER_CALL(glTexFilterFuncSGIS)
        UCT.glTexFilterFuncSGIS(param[0].uv32bit, param[1].uv32bit, param[2].v32bit, (const GLfloat *)param[3].ptr);
    CHECK_GL_CALL(glTexFilterFuncSGIS)
        JT.glTexFilterFuncSGIS(param[0].uv32bit, param[1].uv32bit, param[2].v32bit, (const GLfloat *)param[3].ptr);
}

void STUB_glTexGend( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glTexGend( GLenum coord, GLenum pname, GLdouble param )
    maxParam = 3;
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_DOUBLE_PARAM(2);
    TR.skipLine();
    CHECK_USER_CALL(glTexGend)
        UCT.glTexGend(param[0].uv32bit, param[1].uv32bit, param[2].fv64bit);
    CHECK_GL_CALL(glTexGend)
        JT.glTexGend(param[0].uv32bit, param[1].uv32bit, param[2].fv64bit);
}

void STUB_glTexGendv( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glTexGendv( GLenum coord, GLenum pname, const GLdouble *params )
    maxParam = 3;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_ARRAY_PARAM( 2, buffer0, TraceReader::TEXT_DOUBLE);
    TR.skipLine();
    CHECK_USER_CALL(glTexGendv)
        UCT.glTexGendv(param[0].uv32bit, param[1].uv32bit, (const GLdouble *)param[2].ptr);
    CHECK_GL_CALL(glTexGendv)
        JT.glTexGendv(param[0].uv32bit, param[1].uv32bit, (const GLdouble *)param[2].ptr);
}

void STUB_glTexGenf( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glTexGenf( GLenum coord, GLenum pname, GLfloat param )
    maxParam = 3;
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_PARAM(fv32bit,2);
    TR.skipLine();
    CHECK_USER_CALL(glTexGenf)
        UCT.glTexGenf(param[0].uv32bit, param[1].uv32bit, param[2].fv32bit);
    CHECK_GL_CALL(glTexGenf)
        JT.glTexGenf(param[0].uv32bit, param[1].uv32bit, param[2].fv32bit);
}

void STUB_glTexGenfv( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glTexGenfv( GLenum coord, GLenum pname, const GLfloat *params )
    maxParam = 3;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_ARRAY_PARAM( 2, buffer0, TraceReader::TEXT_FLOAT);
    TR.skipLine();
    CHECK_USER_CALL(glTexGenfv)
        UCT.glTexGenfv(param[0].uv32bit, param[1].uv32bit, (const GLfloat *)param[2].ptr);
    CHECK_GL_CALL(glTexGenfv)
        JT.glTexGenfv(param[0].uv32bit, param[1].uv32bit, (const GLfloat *)param[2].ptr);
}

void STUB_glTexGeni( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glTexGeni( GLenum coord, GLenum pname, GLint param )
    maxParam = 3;
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_PARAM(v32bit,2);
    TR.skipLine();
    CHECK_USER_CALL(glTexGeni)
        UCT.glTexGeni(param[0].uv32bit, param[1].uv32bit, param[2].v32bit);
    CHECK_GL_CALL(glTexGeni)
        JT.glTexGeni(param[0].uv32bit, param[1].uv32bit, param[2].v32bit);
}

void STUB_glTexGeniv( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glTexGeniv( GLenum coord, GLenum pname, const GLint *params )
    maxParam = 3;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_ARRAY_PARAM( 2, buffer0, TraceReader::TEXT_INT);
    TR.skipLine();
    CHECK_USER_CALL(glTexGeniv)
        UCT.glTexGeniv(param[0].uv32bit, param[1].uv32bit, (const GLint *)param[2].ptr);
    CHECK_GL_CALL(glTexGeniv)
        JT.glTexGeniv(param[0].uv32bit, param[1].uv32bit, (const GLint *)param[2].ptr);
}

void STUB_glTexImage1D( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glTexImage1D( GLenum target, GLint level, GLint internalFormat, GLsizei width, GLint border, GLenum format, GLenum type, const GLvoid *pixels )
    maxParam = 8;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_PARAM(v32bit,1);
    READ_PARAM(v32bit,2);
    READ_PARAM(v32bit,3);
    READ_PARAM(v32bit,4);
    READ_ENUM_PARAM(5);
    READ_ENUM_PARAM(6);
    READ_ARRAY_PARAM( 7, buffer0, TraceReader::TEXT_IGNORE);
    TR.skipLine();
    CHECK_USER_CALL(glTexImage1D)
        UCT.glTexImage1D(param[0].uv32bit, param[1].v32bit, param[2].v32bit, param[3].v32bit, param[4].v32bit, param[5].uv32bit, param[6].uv32bit, (const GLvoid *)param[7].ptr);
    CHECK_GL_CALL(glTexImage1D)
        JT.glTexImage1D(param[0].uv32bit, param[1].v32bit, param[2].v32bit, param[3].v32bit, param[4].v32bit, param[5].uv32bit, param[6].uv32bit, (const GLvoid *)param[7].ptr);
}

void STUB_glTexImage2D( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glTexImage2D( GLenum target, GLint level, GLint internalFormat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const GLvoid *pixels )
    maxParam = 9;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_PARAM(v32bit,1);
    READ_PARAM(v32bit,2);
    READ_PARAM(v32bit,3);
    READ_PARAM(v32bit,4);
    READ_PARAM(v32bit,5);
    READ_ENUM_PARAM(6);
    READ_ENUM_PARAM(7);
    READ_ARRAY_PARAM( 8, buffer0, TraceReader::TEXT_IGNORE);
    TR.skipLine();
    CHECK_USER_CALL(glTexImage2D)
        UCT.glTexImage2D(param[0].uv32bit, param[1].v32bit, param[2].v32bit, param[3].v32bit, param[4].v32bit, param[5].v32bit, param[6].uv32bit, param[7].uv32bit, (const GLvoid *)param[8].ptr);
    CHECK_GL_CALL(glTexImage2D)
        JT.glTexImage2D(param[0].uv32bit, param[1].v32bit, param[2].v32bit, param[3].v32bit, param[4].v32bit, param[5].v32bit, param[6].uv32bit, param[7].uv32bit, (const GLvoid *)param[8].ptr);
}

void STUB_glTexImage3D( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glTexImage3D( GLenum target, GLint level, GLint internalFormat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const GLvoid *pixels )
    maxParam = 10;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_PARAM(v32bit,1);
    READ_PARAM(v32bit,2);
    READ_PARAM(v32bit,3);
    READ_PARAM(v32bit,4);
    READ_PARAM(v32bit,5);
    READ_PARAM(v32bit,6);
    READ_ENUM_PARAM(7);
    READ_ENUM_PARAM(8);
    READ_ARRAY_PARAM( 9, buffer0, TraceReader::TEXT_IGNORE);
    TR.skipLine();
    CHECK_USER_CALL(glTexImage3D)
        UCT.glTexImage3D(param[0].uv32bit, param[1].v32bit, param[2].v32bit, param[3].v32bit, param[4].v32bit, param[5].v32bit, param[6].v32bit, param[7].uv32bit, param[8].uv32bit, (const GLvoid *)param[9].ptr);
    CHECK_GL_CALL(glTexImage3D)
        JT.glTexImage3D(param[0].uv32bit, param[1].v32bit, param[2].v32bit, param[3].v32bit, param[4].v32bit, param[5].v32bit, param[6].v32bit, param[7].uv32bit, param[8].uv32bit, (const GLvoid *)param[9].ptr);
}

void STUB_glTexImage3DEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glTexImage3DEXT( GLenum, GLint, GLenum, GLsizei, GLsizei, GLsizei, GLint, GLenum, GLenum, const GLvoid * )
    maxParam = 10;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_PARAM(v32bit,1);
    READ_ENUM_PARAM(2);
    READ_PARAM(v32bit,3);
    READ_PARAM(v32bit,4);
    READ_PARAM(v32bit,5);
    READ_PARAM(v32bit,6);
    READ_ENUM_PARAM(7);
    READ_ENUM_PARAM(8);
    READ_ARRAY_PARAM( 9, buffer0, TraceReader::TEXT_IGNORE);
    TR.skipLine();
    CHECK_USER_CALL(glTexImage3DEXT)
        UCT.glTexImage3DEXT(param[0].uv32bit, param[1].v32bit, param[2].uv32bit, param[3].v32bit, param[4].v32bit, param[5].v32bit, param[6].v32bit, param[7].uv32bit, param[8].uv32bit, (const GLvoid *)param[9].ptr);
    CHECK_GL_CALL(glTexImage3DEXT)
        JT.glTexImage3DEXT(param[0].uv32bit, param[1].v32bit, param[2].uv32bit, param[3].v32bit, param[4].v32bit, param[5].v32bit, param[6].v32bit, param[7].uv32bit, param[8].uv32bit, (const GLvoid *)param[9].ptr);
}

void STUB_glTexImage4DSGIS( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glTexImage4DSGIS( GLenum, GLint, GLenum, GLsizei, GLsizei, GLsizei, GLsizei, GLint, GLenum, GLenum, const GLvoid * )
    maxParam = 11;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_PARAM(v32bit,1);
    READ_ENUM_PARAM(2);
    READ_PARAM(v32bit,3);
    READ_PARAM(v32bit,4);
    READ_PARAM(v32bit,5);
    READ_PARAM(v32bit,6);
    READ_PARAM(v32bit,7);
    READ_ENUM_PARAM(8);
    READ_ENUM_PARAM(9);
    READ_ARRAY_PARAM( 10, buffer0, TraceReader::TEXT_IGNORE);
    TR.skipLine();
    CHECK_USER_CALL(glTexImage4DSGIS)
        UCT.glTexImage4DSGIS(param[0].uv32bit, param[1].v32bit, param[2].uv32bit, param[3].v32bit, param[4].v32bit, param[5].v32bit, param[6].v32bit, param[7].v32bit, param[8].uv32bit, param[9].uv32bit, (const GLvoid *)param[10].ptr);
    CHECK_GL_CALL(glTexImage4DSGIS)
        JT.glTexImage4DSGIS(param[0].uv32bit, param[1].v32bit, param[2].uv32bit, param[3].v32bit, param[4].v32bit, param[5].v32bit, param[6].v32bit, param[7].v32bit, param[8].uv32bit, param[9].uv32bit, (const GLvoid *)param[10].ptr);
}

void STUB_glTexParameterIiv( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glTexParameterIiv( GLenum, GLenum, const GLint * )
    maxParam = 3;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_ARRAY_PARAM( 2, buffer0, TraceReader::TEXT_INT);
    TR.skipLine();
    CHECK_USER_CALL(glTexParameterIiv)
        UCT.glTexParameterIiv(param[0].uv32bit, param[1].uv32bit, (const GLint *)param[2].ptr);
    CHECK_GL_CALL(glTexParameterIiv)
        JT.glTexParameterIiv(param[0].uv32bit, param[1].uv32bit, (const GLint *)param[2].ptr);
}

void STUB_glTexParameterIivEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glTexParameterIivEXT( GLenum, GLenum, const GLint * )
    maxParam = 3;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_ARRAY_PARAM( 2, buffer0, TraceReader::TEXT_INT);
    TR.skipLine();
    CHECK_USER_CALL(glTexParameterIivEXT)
        UCT.glTexParameterIivEXT(param[0].uv32bit, param[1].uv32bit, (const GLint *)param[2].ptr);
    CHECK_GL_CALL(glTexParameterIivEXT)
        JT.glTexParameterIivEXT(param[0].uv32bit, param[1].uv32bit, (const GLint *)param[2].ptr);
}

void STUB_glTexParameterIuiv( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glTexParameterIuiv( GLenum, GLenum, const GLuint * )
    maxParam = 3;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_ARRAY_PARAM( 2, buffer0, TraceReader::TEXT_INT);
    TR.skipLine();
    CHECK_USER_CALL(glTexParameterIuiv)
        UCT.glTexParameterIuiv(param[0].uv32bit, param[1].uv32bit, (const GLuint *)param[2].ptr);
    CHECK_GL_CALL(glTexParameterIuiv)
        JT.glTexParameterIuiv(param[0].uv32bit, param[1].uv32bit, (const GLuint *)param[2].ptr);
}

void STUB_glTexParameterIuivEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glTexParameterIuivEXT( GLenum, GLenum, const GLuint * )
    maxParam = 3;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_ARRAY_PARAM( 2, buffer0, TraceReader::TEXT_INT);
    TR.skipLine();
    CHECK_USER_CALL(glTexParameterIuivEXT)
        UCT.glTexParameterIuivEXT(param[0].uv32bit, param[1].uv32bit, (const GLuint *)param[2].ptr);
    CHECK_GL_CALL(glTexParameterIuivEXT)
        JT.glTexParameterIuivEXT(param[0].uv32bit, param[1].uv32bit, (const GLuint *)param[2].ptr);
}

void STUB_glTexParameterf( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glTexParameterf( GLenum target, GLenum pname, GLfloat param )
    maxParam = 3;
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_PARAM(fv32bit,2);
    TR.skipLine();
    CHECK_USER_CALL(glTexParameterf)
        UCT.glTexParameterf(param[0].uv32bit, param[1].uv32bit, param[2].fv32bit);
    CHECK_GL_CALL(glTexParameterf)
        JT.glTexParameterf(param[0].uv32bit, param[1].uv32bit, param[2].fv32bit);
}

void STUB_glTexParameterfv( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glTexParameterfv( GLenum target, GLenum pname, const GLfloat *params )
    maxParam = 3;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_ARRAY_PARAM( 2, buffer0, TraceReader::TEXT_FLOAT);
    TR.skipLine();
    CHECK_USER_CALL(glTexParameterfv)
        UCT.glTexParameterfv(param[0].uv32bit, param[1].uv32bit, (const GLfloat *)param[2].ptr);
    CHECK_GL_CALL(glTexParameterfv)
        JT.glTexParameterfv(param[0].uv32bit, param[1].uv32bit, (const GLfloat *)param[2].ptr);
}

void STUB_glTexParameteri( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glTexParameteri( GLenum target, GLenum pname, GLint param )
    maxParam = 3;
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_PARAM(v32bit,2);
    TR.skipLine();
    CHECK_USER_CALL(glTexParameteri)
        UCT.glTexParameteri(param[0].uv32bit, param[1].uv32bit, param[2].v32bit);
    CHECK_GL_CALL(glTexParameteri)
        JT.glTexParameteri(param[0].uv32bit, param[1].uv32bit, param[2].v32bit);
}

void STUB_glTexParameteriv( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glTexParameteriv( GLenum target, GLenum pname, const GLint *params )
    maxParam = 3;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_ARRAY_PARAM( 2, buffer0, TraceReader::TEXT_INT);
    TR.skipLine();
    CHECK_USER_CALL(glTexParameteriv)
        UCT.glTexParameteriv(param[0].uv32bit, param[1].uv32bit, (const GLint *)param[2].ptr);
    CHECK_GL_CALL(glTexParameteriv)
        JT.glTexParameteriv(param[0].uv32bit, param[1].uv32bit, (const GLint *)param[2].ptr);
}

void STUB_glTexRenderbufferNV( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glTexRenderbufferNV( GLenum, GLuint )
    maxParam = 2;
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    TR.skipLine();
    CHECK_USER_CALL(glTexRenderbufferNV)
        UCT.glTexRenderbufferNV(param[0].uv32bit, param[1].uv32bit);
    CHECK_GL_CALL(glTexRenderbufferNV)
        JT.glTexRenderbufferNV(param[0].uv32bit, param[1].uv32bit);
}

void STUB_glTexSubImage1D( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glTexSubImage1D( GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const GLvoid *pixels )
    maxParam = 7;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_PARAM(v32bit,1);
    READ_PARAM(v32bit,2);
    READ_PARAM(v32bit,3);
    READ_ENUM_PARAM(4);
    READ_ENUM_PARAM(5);
    READ_ARRAY_PARAM( 6, buffer0, TraceReader::TEXT_IGNORE);
    TR.skipLine();
    CHECK_USER_CALL(glTexSubImage1D)
        UCT.glTexSubImage1D(param[0].uv32bit, param[1].v32bit, param[2].v32bit, param[3].v32bit, param[4].uv32bit, param[5].uv32bit, (const GLvoid *)param[6].ptr);
    CHECK_GL_CALL(glTexSubImage1D)
        JT.glTexSubImage1D(param[0].uv32bit, param[1].v32bit, param[2].v32bit, param[3].v32bit, param[4].uv32bit, param[5].uv32bit, (const GLvoid *)param[6].ptr);
}

void STUB_glTexSubImage1DEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glTexSubImage1DEXT( GLenum, GLint, GLint, GLsizei, GLenum, GLenum, const GLvoid * )
    maxParam = 7;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_PARAM(v32bit,1);
    READ_PARAM(v32bit,2);
    READ_PARAM(v32bit,3);
    READ_ENUM_PARAM(4);
    READ_ENUM_PARAM(5);
    READ_ARRAY_PARAM( 6, buffer0, TraceReader::TEXT_IGNORE);
    TR.skipLine();
    CHECK_USER_CALL(glTexSubImage1DEXT)
        UCT.glTexSubImage1DEXT(param[0].uv32bit, param[1].v32bit, param[2].v32bit, param[3].v32bit, param[4].uv32bit, param[5].uv32bit, (const GLvoid *)param[6].ptr);
    CHECK_GL_CALL(glTexSubImage1DEXT)
        JT.glTexSubImage1DEXT(param[0].uv32bit, param[1].v32bit, param[2].v32bit, param[3].v32bit, param[4].uv32bit, param[5].uv32bit, (const GLvoid *)param[6].ptr);
}

void STUB_glTexSubImage2D( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glTexSubImage2D( GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *pixels )
    maxParam = 9;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_PARAM(v32bit,1);
    READ_PARAM(v32bit,2);
    READ_PARAM(v32bit,3);
    READ_PARAM(v32bit,4);
    READ_PARAM(v32bit,5);
    READ_ENUM_PARAM(6);
    READ_ENUM_PARAM(7);
    READ_ARRAY_PARAM( 8, buffer0, TraceReader::TEXT_IGNORE);
    TR.skipLine();
    CHECK_USER_CALL(glTexSubImage2D)
        UCT.glTexSubImage2D(param[0].uv32bit, param[1].v32bit, param[2].v32bit, param[3].v32bit, param[4].v32bit, param[5].v32bit, param[6].uv32bit, param[7].uv32bit, (const GLvoid *)param[8].ptr);
    CHECK_GL_CALL(glTexSubImage2D)
        JT.glTexSubImage2D(param[0].uv32bit, param[1].v32bit, param[2].v32bit, param[3].v32bit, param[4].v32bit, param[5].v32bit, param[6].uv32bit, param[7].uv32bit, (const GLvoid *)param[8].ptr);
}

void STUB_glTexSubImage2DEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glTexSubImage2DEXT( GLenum, GLint, GLint, GLint, GLsizei, GLsizei, GLenum, GLenum, const GLvoid * )
    maxParam = 9;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_PARAM(v32bit,1);
    READ_PARAM(v32bit,2);
    READ_PARAM(v32bit,3);
    READ_PARAM(v32bit,4);
    READ_PARAM(v32bit,5);
    READ_ENUM_PARAM(6);
    READ_ENUM_PARAM(7);
    READ_ARRAY_PARAM( 8, buffer0, TraceReader::TEXT_IGNORE);
    TR.skipLine();
    CHECK_USER_CALL(glTexSubImage2DEXT)
        UCT.glTexSubImage2DEXT(param[0].uv32bit, param[1].v32bit, param[2].v32bit, param[3].v32bit, param[4].v32bit, param[5].v32bit, param[6].uv32bit, param[7].uv32bit, (const GLvoid *)param[8].ptr);
    CHECK_GL_CALL(glTexSubImage2DEXT)
        JT.glTexSubImage2DEXT(param[0].uv32bit, param[1].v32bit, param[2].v32bit, param[3].v32bit, param[4].v32bit, param[5].v32bit, param[6].uv32bit, param[7].uv32bit, (const GLvoid *)param[8].ptr);
}

void STUB_glTexSubImage3D( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glTexSubImage3D( GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const GLvoid *pixels )
    maxParam = 11;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_PARAM(v32bit,1);
    READ_PARAM(v32bit,2);
    READ_PARAM(v32bit,3);
    READ_PARAM(v32bit,4);
    READ_PARAM(v32bit,5);
    READ_PARAM(v32bit,6);
    READ_PARAM(v32bit,7);
    READ_ENUM_PARAM(8);
    READ_ENUM_PARAM(9);
    READ_ARRAY_PARAM( 10, buffer0, TraceReader::TEXT_IGNORE);
    TR.skipLine();
    CHECK_USER_CALL(glTexSubImage3D)
        UCT.glTexSubImage3D(param[0].uv32bit, param[1].v32bit, param[2].v32bit, param[3].v32bit, param[4].v32bit, param[5].v32bit, param[6].v32bit, param[7].v32bit, param[8].uv32bit, param[9].uv32bit, (const GLvoid *)param[10].ptr);
    CHECK_GL_CALL(glTexSubImage3D)
        JT.glTexSubImage3D(param[0].uv32bit, param[1].v32bit, param[2].v32bit, param[3].v32bit, param[4].v32bit, param[5].v32bit, param[6].v32bit, param[7].v32bit, param[8].uv32bit, param[9].uv32bit, (const GLvoid *)param[10].ptr);
}

void STUB_glTexSubImage3DEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glTexSubImage3DEXT( GLenum, GLint, GLint, GLint, GLint, GLsizei, GLsizei, GLsizei, GLenum, GLenum, const GLvoid * )
    maxParam = 11;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_PARAM(v32bit,1);
    READ_PARAM(v32bit,2);
    READ_PARAM(v32bit,3);
    READ_PARAM(v32bit,4);
    READ_PARAM(v32bit,5);
    READ_PARAM(v32bit,6);
    READ_PARAM(v32bit,7);
    READ_ENUM_PARAM(8);
    READ_ENUM_PARAM(9);
    READ_ARRAY_PARAM( 10, buffer0, TraceReader::TEXT_IGNORE);
    TR.skipLine();
    CHECK_USER_CALL(glTexSubImage3DEXT)
        UCT.glTexSubImage3DEXT(param[0].uv32bit, param[1].v32bit, param[2].v32bit, param[3].v32bit, param[4].v32bit, param[5].v32bit, param[6].v32bit, param[7].v32bit, param[8].uv32bit, param[9].uv32bit, (const GLvoid *)param[10].ptr);
    CHECK_GL_CALL(glTexSubImage3DEXT)
        JT.glTexSubImage3DEXT(param[0].uv32bit, param[1].v32bit, param[2].v32bit, param[3].v32bit, param[4].v32bit, param[5].v32bit, param[6].v32bit, param[7].v32bit, param[8].uv32bit, param[9].uv32bit, (const GLvoid *)param[10].ptr);
}

void STUB_glTexSubImage4DSGIS( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glTexSubImage4DSGIS( GLenum, GLint, GLint, GLint, GLint, GLint, GLsizei, GLsizei, GLsizei, GLsizei, GLenum, GLenum, const GLvoid * )
    maxParam = 13;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_PARAM(v32bit,1);
    READ_PARAM(v32bit,2);
    READ_PARAM(v32bit,3);
    READ_PARAM(v32bit,4);
    READ_PARAM(v32bit,5);
    READ_PARAM(v32bit,6);
    READ_PARAM(v32bit,7);
    READ_PARAM(v32bit,8);
    READ_PARAM(v32bit,9);
    READ_ENUM_PARAM(10);
    READ_ENUM_PARAM(11);
    READ_ARRAY_PARAM( 12, buffer0, TraceReader::TEXT_IGNORE);
    TR.skipLine();
    CHECK_USER_CALL(glTexSubImage4DSGIS)
        UCT.glTexSubImage4DSGIS(param[0].uv32bit, param[1].v32bit, param[2].v32bit, param[3].v32bit, param[4].v32bit, param[5].v32bit, param[6].v32bit, param[7].v32bit, param[8].v32bit, param[9].v32bit, param[10].uv32bit, param[11].uv32bit, (const GLvoid *)param[12].ptr);
    CHECK_GL_CALL(glTexSubImage4DSGIS)
        JT.glTexSubImage4DSGIS(param[0].uv32bit, param[1].v32bit, param[2].v32bit, param[3].v32bit, param[4].v32bit, param[5].v32bit, param[6].v32bit, param[7].v32bit, param[8].v32bit, param[9].v32bit, param[10].uv32bit, param[11].uv32bit, (const GLvoid *)param[12].ptr);
}

void STUB_glTextureBufferEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glTextureBufferEXT( GLuint, GLenum, GLenum, GLuint )
    maxParam = 4;
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_ENUM_PARAM(2);
    READ_ENUM_PARAM(3);
    TR.skipLine();
    CHECK_USER_CALL(glTextureBufferEXT)
        UCT.glTextureBufferEXT(param[0].uv32bit, param[1].uv32bit, param[2].uv32bit, param[3].uv32bit);
    CHECK_GL_CALL(glTextureBufferEXT)
        JT.glTextureBufferEXT(param[0].uv32bit, param[1].uv32bit, param[2].uv32bit, param[3].uv32bit);
}

void STUB_glTextureColorMaskSGIS( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glTextureColorMaskSGIS( GLboolean, GLboolean, GLboolean, GLboolean )
    maxParam = 4;
    READ_BOOLEAN_PARAM(0);
    READ_BOOLEAN_PARAM(1);
    READ_BOOLEAN_PARAM(2);
    READ_BOOLEAN_PARAM(3);
    TR.skipLine();
    CHECK_USER_CALL(glTextureColorMaskSGIS)
        UCT.glTextureColorMaskSGIS(param[0].boolean, param[1].boolean, param[2].boolean, param[3].boolean);
    CHECK_GL_CALL(glTextureColorMaskSGIS)
        JT.glTextureColorMaskSGIS(param[0].boolean, param[1].boolean, param[2].boolean, param[3].boolean);
}

void STUB_glTextureImage1DEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glTextureImage1DEXT( GLuint, GLenum, GLint, GLenum, GLsizei, GLint, GLenum, GLenum, const GLvoid * )
    maxParam = 9;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_PARAM(v32bit,2);
    READ_ENUM_PARAM(3);
    READ_PARAM(v32bit,4);
    READ_PARAM(v32bit,5);
    READ_ENUM_PARAM(6);
    READ_ENUM_PARAM(7);
    READ_ARRAY_PARAM( 8, buffer0, TraceReader::TEXT_IGNORE);
    TR.skipLine();
    CHECK_USER_CALL(glTextureImage1DEXT)
        UCT.glTextureImage1DEXT(param[0].uv32bit, param[1].uv32bit, param[2].v32bit, param[3].uv32bit, param[4].v32bit, param[5].v32bit, param[6].uv32bit, param[7].uv32bit, (const GLvoid *)param[8].ptr);
    CHECK_GL_CALL(glTextureImage1DEXT)
        JT.glTextureImage1DEXT(param[0].uv32bit, param[1].uv32bit, param[2].v32bit, param[3].uv32bit, param[4].v32bit, param[5].v32bit, param[6].uv32bit, param[7].uv32bit, (const GLvoid *)param[8].ptr);
}

void STUB_glTextureImage2DEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glTextureImage2DEXT( GLuint, GLenum, GLint, GLenum, GLsizei, GLsizei, GLint, GLenum, GLenum, const GLvoid * )
    maxParam = 10;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_PARAM(v32bit,2);
    READ_ENUM_PARAM(3);
    READ_PARAM(v32bit,4);
    READ_PARAM(v32bit,5);
    READ_PARAM(v32bit,6);
    READ_ENUM_PARAM(7);
    READ_ENUM_PARAM(8);
    READ_ARRAY_PARAM( 9, buffer0, TraceReader::TEXT_IGNORE);
    TR.skipLine();
    CHECK_USER_CALL(glTextureImage2DEXT)
        UCT.glTextureImage2DEXT(param[0].uv32bit, param[1].uv32bit, param[2].v32bit, param[3].uv32bit, param[4].v32bit, param[5].v32bit, param[6].v32bit, param[7].uv32bit, param[8].uv32bit, (const GLvoid *)param[9].ptr);
    CHECK_GL_CALL(glTextureImage2DEXT)
        JT.glTextureImage2DEXT(param[0].uv32bit, param[1].uv32bit, param[2].v32bit, param[3].uv32bit, param[4].v32bit, param[5].v32bit, param[6].v32bit, param[7].uv32bit, param[8].uv32bit, (const GLvoid *)param[9].ptr);
}

void STUB_glTextureImage3DEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glTextureImage3DEXT( GLuint, GLenum, GLint, GLenum, GLsizei, GLsizei, GLsizei, GLint, GLenum, GLenum, const GLvoid * )
    maxParam = 11;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_PARAM(v32bit,2);
    READ_ENUM_PARAM(3);
    READ_PARAM(v32bit,4);
    READ_PARAM(v32bit,5);
    READ_PARAM(v32bit,6);
    READ_PARAM(v32bit,7);
    READ_ENUM_PARAM(8);
    READ_ENUM_PARAM(9);
    READ_ARRAY_PARAM( 10, buffer0, TraceReader::TEXT_IGNORE);
    TR.skipLine();
    CHECK_USER_CALL(glTextureImage3DEXT)
        UCT.glTextureImage3DEXT(param[0].uv32bit, param[1].uv32bit, param[2].v32bit, param[3].uv32bit, param[4].v32bit, param[5].v32bit, param[6].v32bit, param[7].v32bit, param[8].uv32bit, param[9].uv32bit, (const GLvoid *)param[10].ptr);
    CHECK_GL_CALL(glTextureImage3DEXT)
        JT.glTextureImage3DEXT(param[0].uv32bit, param[1].uv32bit, param[2].v32bit, param[3].uv32bit, param[4].v32bit, param[5].v32bit, param[6].v32bit, param[7].v32bit, param[8].uv32bit, param[9].uv32bit, (const GLvoid *)param[10].ptr);
}

void STUB_glTextureLightEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glTextureLightEXT( GLenum )
    maxParam = 1;
    READ_ENUM_PARAM(0);
    TR.skipLine();
    CHECK_USER_CALL(glTextureLightEXT)
        UCT.glTextureLightEXT(param[0].uv32bit);
    CHECK_GL_CALL(glTextureLightEXT)
        JT.glTextureLightEXT(param[0].uv32bit);
}

void STUB_glTextureMaterialEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glTextureMaterialEXT( GLenum, GLenum )
    maxParam = 2;
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    TR.skipLine();
    CHECK_USER_CALL(glTextureMaterialEXT)
        UCT.glTextureMaterialEXT(param[0].uv32bit, param[1].uv32bit);
    CHECK_GL_CALL(glTextureMaterialEXT)
        JT.glTextureMaterialEXT(param[0].uv32bit, param[1].uv32bit);
}

void STUB_glTextureNormalEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glTextureNormalEXT( GLenum )
    maxParam = 1;
    READ_ENUM_PARAM(0);
    TR.skipLine();
    CHECK_USER_CALL(glTextureNormalEXT)
        UCT.glTextureNormalEXT(param[0].uv32bit);
    CHECK_GL_CALL(glTextureNormalEXT)
        JT.glTextureNormalEXT(param[0].uv32bit);
}

void STUB_glTextureParameterIivEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glTextureParameterIivEXT( GLuint, GLenum, GLenum, const GLint * )
    maxParam = 4;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_ENUM_PARAM(2);
    READ_ARRAY_PARAM( 3, buffer0, TraceReader::TEXT_INT);
    TR.skipLine();
    CHECK_USER_CALL(glTextureParameterIivEXT)
        UCT.glTextureParameterIivEXT(param[0].uv32bit, param[1].uv32bit, param[2].uv32bit, (const GLint *)param[3].ptr);
    CHECK_GL_CALL(glTextureParameterIivEXT)
        JT.glTextureParameterIivEXT(param[0].uv32bit, param[1].uv32bit, param[2].uv32bit, (const GLint *)param[3].ptr);
}

void STUB_glTextureParameterIuivEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glTextureParameterIuivEXT( GLuint, GLenum, GLenum, const GLuint * )
    maxParam = 4;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_ENUM_PARAM(2);
    READ_ARRAY_PARAM( 3, buffer0, TraceReader::TEXT_INT);
    TR.skipLine();
    CHECK_USER_CALL(glTextureParameterIuivEXT)
        UCT.glTextureParameterIuivEXT(param[0].uv32bit, param[1].uv32bit, param[2].uv32bit, (const GLuint *)param[3].ptr);
    CHECK_GL_CALL(glTextureParameterIuivEXT)
        JT.glTextureParameterIuivEXT(param[0].uv32bit, param[1].uv32bit, param[2].uv32bit, (const GLuint *)param[3].ptr);
}

void STUB_glTextureParameterfEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glTextureParameterfEXT( GLuint, GLenum, GLenum, GLfloat )
    maxParam = 4;
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_ENUM_PARAM(2);
    READ_PARAM(fv32bit,3);
    TR.skipLine();
    CHECK_USER_CALL(glTextureParameterfEXT)
        UCT.glTextureParameterfEXT(param[0].uv32bit, param[1].uv32bit, param[2].uv32bit, param[3].fv32bit);
    CHECK_GL_CALL(glTextureParameterfEXT)
        JT.glTextureParameterfEXT(param[0].uv32bit, param[1].uv32bit, param[2].uv32bit, param[3].fv32bit);
}

void STUB_glTextureParameterfvEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glTextureParameterfvEXT( GLuint, GLenum, GLenum, const GLfloat * )
    maxParam = 4;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_ENUM_PARAM(2);
    READ_ARRAY_PARAM( 3, buffer0, TraceReader::TEXT_FLOAT);
    TR.skipLine();
    CHECK_USER_CALL(glTextureParameterfvEXT)
        UCT.glTextureParameterfvEXT(param[0].uv32bit, param[1].uv32bit, param[2].uv32bit, (const GLfloat *)param[3].ptr);
    CHECK_GL_CALL(glTextureParameterfvEXT)
        JT.glTextureParameterfvEXT(param[0].uv32bit, param[1].uv32bit, param[2].uv32bit, (const GLfloat *)param[3].ptr);
}

void STUB_glTextureParameteriEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glTextureParameteriEXT( GLuint, GLenum, GLenum, GLint )
    maxParam = 4;
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_ENUM_PARAM(2);
    READ_PARAM(v32bit,3);
    TR.skipLine();
    CHECK_USER_CALL(glTextureParameteriEXT)
        UCT.glTextureParameteriEXT(param[0].uv32bit, param[1].uv32bit, param[2].uv32bit, param[3].v32bit);
    CHECK_GL_CALL(glTextureParameteriEXT)
        JT.glTextureParameteriEXT(param[0].uv32bit, param[1].uv32bit, param[2].uv32bit, param[3].v32bit);
}

void STUB_glTextureParameterivEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glTextureParameterivEXT( GLuint, GLenum, GLenum, const GLint * )
    maxParam = 4;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_ENUM_PARAM(2);
    READ_ARRAY_PARAM( 3, buffer0, TraceReader::TEXT_INT);
    TR.skipLine();
    CHECK_USER_CALL(glTextureParameterivEXT)
        UCT.glTextureParameterivEXT(param[0].uv32bit, param[1].uv32bit, param[2].uv32bit, (const GLint *)param[3].ptr);
    CHECK_GL_CALL(glTextureParameterivEXT)
        JT.glTextureParameterivEXT(param[0].uv32bit, param[1].uv32bit, param[2].uv32bit, (const GLint *)param[3].ptr);
}

void STUB_glTextureRenderbufferEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glTextureRenderbufferEXT( GLuint, GLenum, GLuint )
    maxParam = 3;
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_ENUM_PARAM(2);
    TR.skipLine();
    CHECK_USER_CALL(glTextureRenderbufferEXT)
        UCT.glTextureRenderbufferEXT(param[0].uv32bit, param[1].uv32bit, param[2].uv32bit);
    CHECK_GL_CALL(glTextureRenderbufferEXT)
        JT.glTextureRenderbufferEXT(param[0].uv32bit, param[1].uv32bit, param[2].uv32bit);
}

void STUB_glTextureSubImage1DEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glTextureSubImage1DEXT( GLuint, GLenum, GLint, GLint, GLsizei, GLenum, GLenum, const GLvoid * )
    maxParam = 8;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_PARAM(v32bit,2);
    READ_PARAM(v32bit,3);
    READ_PARAM(v32bit,4);
    READ_ENUM_PARAM(5);
    READ_ENUM_PARAM(6);
    READ_ARRAY_PARAM( 7, buffer0, TraceReader::TEXT_IGNORE);
    TR.skipLine();
    CHECK_USER_CALL(glTextureSubImage1DEXT)
        UCT.glTextureSubImage1DEXT(param[0].uv32bit, param[1].uv32bit, param[2].v32bit, param[3].v32bit, param[4].v32bit, param[5].uv32bit, param[6].uv32bit, (const GLvoid *)param[7].ptr);
    CHECK_GL_CALL(glTextureSubImage1DEXT)
        JT.glTextureSubImage1DEXT(param[0].uv32bit, param[1].uv32bit, param[2].v32bit, param[3].v32bit, param[4].v32bit, param[5].uv32bit, param[6].uv32bit, (const GLvoid *)param[7].ptr);
}

void STUB_glTextureSubImage2DEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glTextureSubImage2DEXT( GLuint, GLenum, GLint, GLint, GLint, GLsizei, GLsizei, GLenum, GLenum, const GLvoid * )
    maxParam = 10;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_PARAM(v32bit,2);
    READ_PARAM(v32bit,3);
    READ_PARAM(v32bit,4);
    READ_PARAM(v32bit,5);
    READ_PARAM(v32bit,6);
    READ_ENUM_PARAM(7);
    READ_ENUM_PARAM(8);
    READ_ARRAY_PARAM( 9, buffer0, TraceReader::TEXT_IGNORE);
    TR.skipLine();
    CHECK_USER_CALL(glTextureSubImage2DEXT)
        UCT.glTextureSubImage2DEXT(param[0].uv32bit, param[1].uv32bit, param[2].v32bit, param[3].v32bit, param[4].v32bit, param[5].v32bit, param[6].v32bit, param[7].uv32bit, param[8].uv32bit, (const GLvoid *)param[9].ptr);
    CHECK_GL_CALL(glTextureSubImage2DEXT)
        JT.glTextureSubImage2DEXT(param[0].uv32bit, param[1].uv32bit, param[2].v32bit, param[3].v32bit, param[4].v32bit, param[5].v32bit, param[6].v32bit, param[7].uv32bit, param[8].uv32bit, (const GLvoid *)param[9].ptr);
}

void STUB_glTextureSubImage3DEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glTextureSubImage3DEXT( GLuint, GLenum, GLint, GLint, GLint, GLint, GLsizei, GLsizei, GLsizei, GLenum, GLenum, const GLvoid * )
    maxParam = 12;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_PARAM(v32bit,2);
    READ_PARAM(v32bit,3);
    READ_PARAM(v32bit,4);
    READ_PARAM(v32bit,5);
    READ_PARAM(v32bit,6);
    READ_PARAM(v32bit,7);
    READ_PARAM(v32bit,8);
    READ_ENUM_PARAM(9);
    READ_ENUM_PARAM(10);
    READ_ARRAY_PARAM( 11, buffer0, TraceReader::TEXT_IGNORE);
    TR.skipLine();
    CHECK_USER_CALL(glTextureSubImage3DEXT)
        UCT.glTextureSubImage3DEXT(param[0].uv32bit, param[1].uv32bit, param[2].v32bit, param[3].v32bit, param[4].v32bit, param[5].v32bit, param[6].v32bit, param[7].v32bit, param[8].v32bit, param[9].uv32bit, param[10].uv32bit, (const GLvoid *)param[11].ptr);
    CHECK_GL_CALL(glTextureSubImage3DEXT)
        JT.glTextureSubImage3DEXT(param[0].uv32bit, param[1].uv32bit, param[2].v32bit, param[3].v32bit, param[4].v32bit, param[5].v32bit, param[6].v32bit, param[7].v32bit, param[8].v32bit, param[9].uv32bit, param[10].uv32bit, (const GLvoid *)param[11].ptr);
}

void STUB_glTrackMatrixNV( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glTrackMatrixNV( GLenum, GLuint, GLenum, GLenum )
    maxParam = 4;
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_ENUM_PARAM(2);
    READ_ENUM_PARAM(3);
    TR.skipLine();
    CHECK_USER_CALL(glTrackMatrixNV)
        UCT.glTrackMatrixNV(param[0].uv32bit, param[1].uv32bit, param[2].uv32bit, param[3].uv32bit);
    CHECK_GL_CALL(glTrackMatrixNV)
        JT.glTrackMatrixNV(param[0].uv32bit, param[1].uv32bit, param[2].uv32bit, param[3].uv32bit);
}

void STUB_glTransformFeedbackAttribsNV( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glTransformFeedbackAttribsNV( GLuint, const GLint *, GLenum )
    maxParam = 3;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ARRAY_PARAM( 1, buffer0, TraceReader::TEXT_INT);
    READ_ENUM_PARAM(2);
    TR.skipLine();
    CHECK_USER_CALL(glTransformFeedbackAttribsNV)
        UCT.glTransformFeedbackAttribsNV(param[0].uv32bit, (const GLint *)param[1].ptr, param[2].uv32bit);
    CHECK_GL_CALL(glTransformFeedbackAttribsNV)
        JT.glTransformFeedbackAttribsNV(param[0].uv32bit, (const GLint *)param[1].ptr, param[2].uv32bit);
}

void STUB_glTransformFeedbackVaryings( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glTransformFeedbackVaryings( GLuint, GLsizei, const GLchar **, GLenum )
    // Call not playable
    TR.skipCall();
}

void STUB_glTransformFeedbackVaryingsEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glTransformFeedbackVaryingsEXT( GLuint, GLsizei, const GLchar **, GLenum )
    // Call not playable
    TR.skipCall();
}

void STUB_glTransformFeedbackVaryingsNV( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glTransformFeedbackVaryingsNV( GLuint, GLsizei, const GLint *, GLenum )
    maxParam = 4;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_PARAM(v32bit,1);
    READ_ARRAY_PARAM( 2, buffer0, TraceReader::TEXT_INT);
    READ_ENUM_PARAM(3);
    TR.skipLine();
    CHECK_USER_CALL(glTransformFeedbackVaryingsNV)
        UCT.glTransformFeedbackVaryingsNV(param[0].uv32bit, param[1].v32bit, (const GLint *)param[2].ptr, param[3].uv32bit);
    CHECK_GL_CALL(glTransformFeedbackVaryingsNV)
        JT.glTransformFeedbackVaryingsNV(param[0].uv32bit, param[1].v32bit, (const GLint *)param[2].ptr, param[3].uv32bit);
}

void STUB_glTranslated( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glTranslated( GLdouble x, GLdouble y, GLdouble z )
    maxParam = 3;
    READ_DOUBLE_PARAM(0);
    READ_DOUBLE_PARAM(1);
    READ_DOUBLE_PARAM(2);
    TR.skipLine();
    CHECK_USER_CALL(glTranslated)
        UCT.glTranslated(param[0].fv64bit, param[1].fv64bit, param[2].fv64bit);
    CHECK_GL_CALL(glTranslated)
        JT.glTranslated(param[0].fv64bit, param[1].fv64bit, param[2].fv64bit);
}

void STUB_glTranslatef( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glTranslatef( GLfloat x, GLfloat y, GLfloat z )
    maxParam = 3;
    READ_PARAM(fv32bit,0);
    READ_PARAM(fv32bit,1);
    READ_PARAM(fv32bit,2);
    TR.skipLine();
    CHECK_USER_CALL(glTranslatef)
        UCT.glTranslatef(param[0].fv32bit, param[1].fv32bit, param[2].fv32bit);
    CHECK_GL_CALL(glTranslatef)
        JT.glTranslatef(param[0].fv32bit, param[1].fv32bit, param[2].fv32bit);
}

void STUB_glUniform1f( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glUniform1f( GLint, GLfloat )
    maxParam = 2;
    READ_PARAM(v32bit,0);
    READ_PARAM(fv32bit,1);
    TR.skipLine();
    CHECK_USER_CALL(glUniform1f)
        UCT.glUniform1f(param[0].v32bit, param[1].fv32bit);
    CHECK_GL_CALL(glUniform1f)
        JT.glUniform1f(param[0].v32bit, param[1].fv32bit);
}

void STUB_glUniform1fARB( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glUniform1fARB( GLint, GLfloat )
    maxParam = 2;
    READ_PARAM(v32bit,0);
    READ_PARAM(fv32bit,1);
    TR.skipLine();
    CHECK_USER_CALL(glUniform1fARB)
        UCT.glUniform1fARB(param[0].v32bit, param[1].fv32bit);
    CHECK_GL_CALL(glUniform1fARB)
        JT.glUniform1fARB(param[0].v32bit, param[1].fv32bit);
}

void STUB_glUniform1fv( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glUniform1fv( GLint, GLsizei, const GLfloat * )
    maxParam = 3;
    char buffer0[16*4096];
    READ_PARAM(v32bit,0);
    READ_PARAM(v32bit,1);
    READ_ARRAY_PARAM( 2, buffer0, TraceReader::TEXT_FLOAT);
    TR.skipLine();
    CHECK_USER_CALL(glUniform1fv)
        UCT.glUniform1fv(param[0].v32bit, param[1].v32bit, (const GLfloat *)param[2].ptr);
    CHECK_GL_CALL(glUniform1fv)
        JT.glUniform1fv(param[0].v32bit, param[1].v32bit, (const GLfloat *)param[2].ptr);
}

void STUB_glUniform1fvARB( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glUniform1fvARB( GLint, GLsizei, const GLfloat * )
    maxParam = 3;
    char buffer0[16*4096];
    READ_PARAM(v32bit,0);
    READ_PARAM(v32bit,1);
    READ_ARRAY_PARAM( 2, buffer0, TraceReader::TEXT_FLOAT);
    TR.skipLine();
    CHECK_USER_CALL(glUniform1fvARB)
        UCT.glUniform1fvARB(param[0].v32bit, param[1].v32bit, (const GLfloat *)param[2].ptr);
    CHECK_GL_CALL(glUniform1fvARB)
        JT.glUniform1fvARB(param[0].v32bit, param[1].v32bit, (const GLfloat *)param[2].ptr);
}

void STUB_glUniform1i( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glUniform1i( GLint, GLint )
    maxParam = 2;
    READ_PARAM(v32bit,0);
    READ_PARAM(v32bit,1);
    TR.skipLine();
    CHECK_USER_CALL(glUniform1i)
        UCT.glUniform1i(param[0].v32bit, param[1].v32bit);
    CHECK_GL_CALL(glUniform1i)
        JT.glUniform1i(param[0].v32bit, param[1].v32bit);
}

void STUB_glUniform1iARB( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glUniform1iARB( GLint, GLint )
    maxParam = 2;
    READ_PARAM(v32bit,0);
    READ_PARAM(v32bit,1);
    TR.skipLine();
    CHECK_USER_CALL(glUniform1iARB)
        UCT.glUniform1iARB(param[0].v32bit, param[1].v32bit);
    CHECK_GL_CALL(glUniform1iARB)
        JT.glUniform1iARB(param[0].v32bit, param[1].v32bit);
}

void STUB_glUniform1iv( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glUniform1iv( GLint, GLsizei, const GLint * )
    maxParam = 3;
    char buffer0[16*4096];
    READ_PARAM(v32bit,0);
    READ_PARAM(v32bit,1);
    READ_ARRAY_PARAM( 2, buffer0, TraceReader::TEXT_INT);
    TR.skipLine();
    CHECK_USER_CALL(glUniform1iv)
        UCT.glUniform1iv(param[0].v32bit, param[1].v32bit, (const GLint *)param[2].ptr);
    CHECK_GL_CALL(glUniform1iv)
        JT.glUniform1iv(param[0].v32bit, param[1].v32bit, (const GLint *)param[2].ptr);
}

void STUB_glUniform1ivARB( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glUniform1ivARB( GLint, GLsizei, const GLint * )
    maxParam = 3;
    char buffer0[16*4096];
    READ_PARAM(v32bit,0);
    READ_PARAM(v32bit,1);
    READ_ARRAY_PARAM( 2, buffer0, TraceReader::TEXT_INT);
    TR.skipLine();
    CHECK_USER_CALL(glUniform1ivARB)
        UCT.glUniform1ivARB(param[0].v32bit, param[1].v32bit, (const GLint *)param[2].ptr);
    CHECK_GL_CALL(glUniform1ivARB)
        JT.glUniform1ivARB(param[0].v32bit, param[1].v32bit, (const GLint *)param[2].ptr);
}

void STUB_glUniform1ui( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glUniform1ui( GLint, GLuint )
    maxParam = 2;
    READ_PARAM(v32bit,0);
    READ_ENUM_PARAM(1);
    TR.skipLine();
    CHECK_USER_CALL(glUniform1ui)
        UCT.glUniform1ui(param[0].v32bit, param[1].uv32bit);
    CHECK_GL_CALL(glUniform1ui)
        JT.glUniform1ui(param[0].v32bit, param[1].uv32bit);
}

void STUB_glUniform1uiEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glUniform1uiEXT( GLint, GLuint )
    maxParam = 2;
    READ_PARAM(v32bit,0);
    READ_ENUM_PARAM(1);
    TR.skipLine();
    CHECK_USER_CALL(glUniform1uiEXT)
        UCT.glUniform1uiEXT(param[0].v32bit, param[1].uv32bit);
    CHECK_GL_CALL(glUniform1uiEXT)
        JT.glUniform1uiEXT(param[0].v32bit, param[1].uv32bit);
}

void STUB_glUniform1uiv( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glUniform1uiv( GLint, GLsizei, const GLuint * )
    maxParam = 3;
    char buffer0[16*4096];
    READ_PARAM(v32bit,0);
    READ_PARAM(v32bit,1);
    READ_ARRAY_PARAM( 2, buffer0, TraceReader::TEXT_INT);
    TR.skipLine();
    CHECK_USER_CALL(glUniform1uiv)
        UCT.glUniform1uiv(param[0].v32bit, param[1].v32bit, (const GLuint *)param[2].ptr);
    CHECK_GL_CALL(glUniform1uiv)
        JT.glUniform1uiv(param[0].v32bit, param[1].v32bit, (const GLuint *)param[2].ptr);
}

void STUB_glUniform1uivEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glUniform1uivEXT( GLint, GLsizei, const GLuint * )
    maxParam = 3;
    char buffer0[16*4096];
    READ_PARAM(v32bit,0);
    READ_PARAM(v32bit,1);
    READ_ARRAY_PARAM( 2, buffer0, TraceReader::TEXT_INT);
    TR.skipLine();
    CHECK_USER_CALL(glUniform1uivEXT)
        UCT.glUniform1uivEXT(param[0].v32bit, param[1].v32bit, (const GLuint *)param[2].ptr);
    CHECK_GL_CALL(glUniform1uivEXT)
        JT.glUniform1uivEXT(param[0].v32bit, param[1].v32bit, (const GLuint *)param[2].ptr);
}

void STUB_glUniform2f( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glUniform2f( GLint, GLfloat, GLfloat )
    maxParam = 3;
    READ_PARAM(v32bit,0);
    READ_PARAM(fv32bit,1);
    READ_PARAM(fv32bit,2);
    TR.skipLine();
    CHECK_USER_CALL(glUniform2f)
        UCT.glUniform2f(param[0].v32bit, param[1].fv32bit, param[2].fv32bit);
    CHECK_GL_CALL(glUniform2f)
        JT.glUniform2f(param[0].v32bit, param[1].fv32bit, param[2].fv32bit);
}

void STUB_glUniform2fARB( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glUniform2fARB( GLint, GLfloat, GLfloat )
    maxParam = 3;
    READ_PARAM(v32bit,0);
    READ_PARAM(fv32bit,1);
    READ_PARAM(fv32bit,2);
    TR.skipLine();
    CHECK_USER_CALL(glUniform2fARB)
        UCT.glUniform2fARB(param[0].v32bit, param[1].fv32bit, param[2].fv32bit);
    CHECK_GL_CALL(glUniform2fARB)
        JT.glUniform2fARB(param[0].v32bit, param[1].fv32bit, param[2].fv32bit);
}

void STUB_glUniform2fv( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glUniform2fv( GLint, GLsizei, const GLfloat * )
    maxParam = 3;
    char buffer0[16*4096];
    READ_PARAM(v32bit,0);
    READ_PARAM(v32bit,1);
    READ_ARRAY_PARAM( 2, buffer0, TraceReader::TEXT_FLOAT);
    TR.skipLine();
    CHECK_USER_CALL(glUniform2fv)
        UCT.glUniform2fv(param[0].v32bit, param[1].v32bit, (const GLfloat *)param[2].ptr);
    CHECK_GL_CALL(glUniform2fv)
        JT.glUniform2fv(param[0].v32bit, param[1].v32bit, (const GLfloat *)param[2].ptr);
}

void STUB_glUniform2fvARB( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glUniform2fvARB( GLint, GLsizei, const GLfloat * )
    maxParam = 3;
    char buffer0[16*4096];
    READ_PARAM(v32bit,0);
    READ_PARAM(v32bit,1);
    READ_ARRAY_PARAM( 2, buffer0, TraceReader::TEXT_FLOAT);
    TR.skipLine();
    CHECK_USER_CALL(glUniform2fvARB)
        UCT.glUniform2fvARB(param[0].v32bit, param[1].v32bit, (const GLfloat *)param[2].ptr);
    CHECK_GL_CALL(glUniform2fvARB)
        JT.glUniform2fvARB(param[0].v32bit, param[1].v32bit, (const GLfloat *)param[2].ptr);
}

void STUB_glUniform2i( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glUniform2i( GLint, GLint, GLint )
    maxParam = 3;
    READ_PARAM(v32bit,0);
    READ_PARAM(v32bit,1);
    READ_PARAM(v32bit,2);
    TR.skipLine();
    CHECK_USER_CALL(glUniform2i)
        UCT.glUniform2i(param[0].v32bit, param[1].v32bit, param[2].v32bit);
    CHECK_GL_CALL(glUniform2i)
        JT.glUniform2i(param[0].v32bit, param[1].v32bit, param[2].v32bit);
}

void STUB_glUniform2iARB( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glUniform2iARB( GLint, GLint, GLint )
    maxParam = 3;
    READ_PARAM(v32bit,0);
    READ_PARAM(v32bit,1);
    READ_PARAM(v32bit,2);
    TR.skipLine();
    CHECK_USER_CALL(glUniform2iARB)
        UCT.glUniform2iARB(param[0].v32bit, param[1].v32bit, param[2].v32bit);
    CHECK_GL_CALL(glUniform2iARB)
        JT.glUniform2iARB(param[0].v32bit, param[1].v32bit, param[2].v32bit);
}

void STUB_glUniform2iv( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glUniform2iv( GLint, GLsizei, const GLint * )
    maxParam = 3;
    char buffer0[16*4096];
    READ_PARAM(v32bit,0);
    READ_PARAM(v32bit,1);
    READ_ARRAY_PARAM( 2, buffer0, TraceReader::TEXT_INT);
    TR.skipLine();
    CHECK_USER_CALL(glUniform2iv)
        UCT.glUniform2iv(param[0].v32bit, param[1].v32bit, (const GLint *)param[2].ptr);
    CHECK_GL_CALL(glUniform2iv)
        JT.glUniform2iv(param[0].v32bit, param[1].v32bit, (const GLint *)param[2].ptr);
}

void STUB_glUniform2ivARB( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glUniform2ivARB( GLint, GLsizei, const GLint * )
    maxParam = 3;
    char buffer0[16*4096];
    READ_PARAM(v32bit,0);
    READ_PARAM(v32bit,1);
    READ_ARRAY_PARAM( 2, buffer0, TraceReader::TEXT_INT);
    TR.skipLine();
    CHECK_USER_CALL(glUniform2ivARB)
        UCT.glUniform2ivARB(param[0].v32bit, param[1].v32bit, (const GLint *)param[2].ptr);
    CHECK_GL_CALL(glUniform2ivARB)
        JT.glUniform2ivARB(param[0].v32bit, param[1].v32bit, (const GLint *)param[2].ptr);
}

void STUB_glUniform2ui( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glUniform2ui( GLint, GLuint, GLuint )
    maxParam = 3;
    READ_PARAM(v32bit,0);
    READ_ENUM_PARAM(1);
    READ_ENUM_PARAM(2);
    TR.skipLine();
    CHECK_USER_CALL(glUniform2ui)
        UCT.glUniform2ui(param[0].v32bit, param[1].uv32bit, param[2].uv32bit);
    CHECK_GL_CALL(glUniform2ui)
        JT.glUniform2ui(param[0].v32bit, param[1].uv32bit, param[2].uv32bit);
}

void STUB_glUniform2uiEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glUniform2uiEXT( GLint, GLuint, GLuint )
    maxParam = 3;
    READ_PARAM(v32bit,0);
    READ_ENUM_PARAM(1);
    READ_ENUM_PARAM(2);
    TR.skipLine();
    CHECK_USER_CALL(glUniform2uiEXT)
        UCT.glUniform2uiEXT(param[0].v32bit, param[1].uv32bit, param[2].uv32bit);
    CHECK_GL_CALL(glUniform2uiEXT)
        JT.glUniform2uiEXT(param[0].v32bit, param[1].uv32bit, param[2].uv32bit);
}

void STUB_glUniform2uiv( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glUniform2uiv( GLint, GLsizei, const GLuint * )
    maxParam = 3;
    char buffer0[16*4096];
    READ_PARAM(v32bit,0);
    READ_PARAM(v32bit,1);
    READ_ARRAY_PARAM( 2, buffer0, TraceReader::TEXT_INT);
    TR.skipLine();
    CHECK_USER_CALL(glUniform2uiv)
        UCT.glUniform2uiv(param[0].v32bit, param[1].v32bit, (const GLuint *)param[2].ptr);
    CHECK_GL_CALL(glUniform2uiv)
        JT.glUniform2uiv(param[0].v32bit, param[1].v32bit, (const GLuint *)param[2].ptr);
}

void STUB_glUniform2uivEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glUniform2uivEXT( GLint, GLsizei, const GLuint * )
    maxParam = 3;
    char buffer0[16*4096];
    READ_PARAM(v32bit,0);
    READ_PARAM(v32bit,1);
    READ_ARRAY_PARAM( 2, buffer0, TraceReader::TEXT_INT);
    TR.skipLine();
    CHECK_USER_CALL(glUniform2uivEXT)
        UCT.glUniform2uivEXT(param[0].v32bit, param[1].v32bit, (const GLuint *)param[2].ptr);
    CHECK_GL_CALL(glUniform2uivEXT)
        JT.glUniform2uivEXT(param[0].v32bit, param[1].v32bit, (const GLuint *)param[2].ptr);
}

void STUB_glUniform3f( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glUniform3f( GLint, GLfloat, GLfloat, GLfloat )
    maxParam = 4;
    READ_PARAM(v32bit,0);
    READ_PARAM(fv32bit,1);
    READ_PARAM(fv32bit,2);
    READ_PARAM(fv32bit,3);
    TR.skipLine();
    CHECK_USER_CALL(glUniform3f)
        UCT.glUniform3f(param[0].v32bit, param[1].fv32bit, param[2].fv32bit, param[3].fv32bit);
    CHECK_GL_CALL(glUniform3f)
        JT.glUniform3f(param[0].v32bit, param[1].fv32bit, param[2].fv32bit, param[3].fv32bit);
}

void STUB_glUniform3fARB( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glUniform3fARB( GLint, GLfloat, GLfloat, GLfloat )
    maxParam = 4;
    READ_PARAM(v32bit,0);
    READ_PARAM(fv32bit,1);
    READ_PARAM(fv32bit,2);
    READ_PARAM(fv32bit,3);
    TR.skipLine();
    CHECK_USER_CALL(glUniform3fARB)
        UCT.glUniform3fARB(param[0].v32bit, param[1].fv32bit, param[2].fv32bit, param[3].fv32bit);
    CHECK_GL_CALL(glUniform3fARB)
        JT.glUniform3fARB(param[0].v32bit, param[1].fv32bit, param[2].fv32bit, param[3].fv32bit);
}

void STUB_glUniform3fv( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glUniform3fv( GLint, GLsizei, const GLfloat * )
    maxParam = 3;
    char buffer0[16*4096];
    READ_PARAM(v32bit,0);
    READ_PARAM(v32bit,1);
    READ_ARRAY_PARAM( 2, buffer0, TraceReader::TEXT_FLOAT);
    TR.skipLine();
    CHECK_USER_CALL(glUniform3fv)
        UCT.glUniform3fv(param[0].v32bit, param[1].v32bit, (const GLfloat *)param[2].ptr);
    CHECK_GL_CALL(glUniform3fv)
        JT.glUniform3fv(param[0].v32bit, param[1].v32bit, (const GLfloat *)param[2].ptr);
}

void STUB_glUniform3fvARB( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glUniform3fvARB( GLint, GLsizei, const GLfloat * )
    maxParam = 3;
    char buffer0[16*4096];
    READ_PARAM(v32bit,0);
    READ_PARAM(v32bit,1);
    READ_ARRAY_PARAM( 2, buffer0, TraceReader::TEXT_FLOAT);
    TR.skipLine();
    CHECK_USER_CALL(glUniform3fvARB)
        UCT.glUniform3fvARB(param[0].v32bit, param[1].v32bit, (const GLfloat *)param[2].ptr);
    CHECK_GL_CALL(glUniform3fvARB)
        JT.glUniform3fvARB(param[0].v32bit, param[1].v32bit, (const GLfloat *)param[2].ptr);
}

void STUB_glUniform3i( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glUniform3i( GLint, GLint, GLint, GLint )
    maxParam = 4;
    READ_PARAM(v32bit,0);
    READ_PARAM(v32bit,1);
    READ_PARAM(v32bit,2);
    READ_PARAM(v32bit,3);
    TR.skipLine();
    CHECK_USER_CALL(glUniform3i)
        UCT.glUniform3i(param[0].v32bit, param[1].v32bit, param[2].v32bit, param[3].v32bit);
    CHECK_GL_CALL(glUniform3i)
        JT.glUniform3i(param[0].v32bit, param[1].v32bit, param[2].v32bit, param[3].v32bit);
}

void STUB_glUniform3iARB( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glUniform3iARB( GLint, GLint, GLint, GLint )
    maxParam = 4;
    READ_PARAM(v32bit,0);
    READ_PARAM(v32bit,1);
    READ_PARAM(v32bit,2);
    READ_PARAM(v32bit,3);
    TR.skipLine();
    CHECK_USER_CALL(glUniform3iARB)
        UCT.glUniform3iARB(param[0].v32bit, param[1].v32bit, param[2].v32bit, param[3].v32bit);
    CHECK_GL_CALL(glUniform3iARB)
        JT.glUniform3iARB(param[0].v32bit, param[1].v32bit, param[2].v32bit, param[3].v32bit);
}

void STUB_glUniform3iv( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glUniform3iv( GLint, GLsizei, const GLint * )
    maxParam = 3;
    char buffer0[16*4096];
    READ_PARAM(v32bit,0);
    READ_PARAM(v32bit,1);
    READ_ARRAY_PARAM( 2, buffer0, TraceReader::TEXT_INT);
    TR.skipLine();
    CHECK_USER_CALL(glUniform3iv)
        UCT.glUniform3iv(param[0].v32bit, param[1].v32bit, (const GLint *)param[2].ptr);
    CHECK_GL_CALL(glUniform3iv)
        JT.glUniform3iv(param[0].v32bit, param[1].v32bit, (const GLint *)param[2].ptr);
}

void STUB_glUniform3ivARB( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glUniform3ivARB( GLint, GLsizei, const GLint * )
    maxParam = 3;
    char buffer0[16*4096];
    READ_PARAM(v32bit,0);
    READ_PARAM(v32bit,1);
    READ_ARRAY_PARAM( 2, buffer0, TraceReader::TEXT_INT);
    TR.skipLine();
    CHECK_USER_CALL(glUniform3ivARB)
        UCT.glUniform3ivARB(param[0].v32bit, param[1].v32bit, (const GLint *)param[2].ptr);
    CHECK_GL_CALL(glUniform3ivARB)
        JT.glUniform3ivARB(param[0].v32bit, param[1].v32bit, (const GLint *)param[2].ptr);
}

void STUB_glUniform3ui( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glUniform3ui( GLint, GLuint, GLuint, GLuint )
    maxParam = 4;
    READ_PARAM(v32bit,0);
    READ_ENUM_PARAM(1);
    READ_ENUM_PARAM(2);
    READ_ENUM_PARAM(3);
    TR.skipLine();
    CHECK_USER_CALL(glUniform3ui)
        UCT.glUniform3ui(param[0].v32bit, param[1].uv32bit, param[2].uv32bit, param[3].uv32bit);
    CHECK_GL_CALL(glUniform3ui)
        JT.glUniform3ui(param[0].v32bit, param[1].uv32bit, param[2].uv32bit, param[3].uv32bit);
}

void STUB_glUniform3uiEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glUniform3uiEXT( GLint, GLuint, GLuint, GLuint )
    maxParam = 4;
    READ_PARAM(v32bit,0);
    READ_ENUM_PARAM(1);
    READ_ENUM_PARAM(2);
    READ_ENUM_PARAM(3);
    TR.skipLine();
    CHECK_USER_CALL(glUniform3uiEXT)
        UCT.glUniform3uiEXT(param[0].v32bit, param[1].uv32bit, param[2].uv32bit, param[3].uv32bit);
    CHECK_GL_CALL(glUniform3uiEXT)
        JT.glUniform3uiEXT(param[0].v32bit, param[1].uv32bit, param[2].uv32bit, param[3].uv32bit);
}

void STUB_glUniform3uiv( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glUniform3uiv( GLint, GLsizei, const GLuint * )
    maxParam = 3;
    char buffer0[16*4096];
    READ_PARAM(v32bit,0);
    READ_PARAM(v32bit,1);
    READ_ARRAY_PARAM( 2, buffer0, TraceReader::TEXT_INT);
    TR.skipLine();
    CHECK_USER_CALL(glUniform3uiv)
        UCT.glUniform3uiv(param[0].v32bit, param[1].v32bit, (const GLuint *)param[2].ptr);
    CHECK_GL_CALL(glUniform3uiv)
        JT.glUniform3uiv(param[0].v32bit, param[1].v32bit, (const GLuint *)param[2].ptr);
}

void STUB_glUniform3uivEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glUniform3uivEXT( GLint, GLsizei, const GLuint * )
    maxParam = 3;
    char buffer0[16*4096];
    READ_PARAM(v32bit,0);
    READ_PARAM(v32bit,1);
    READ_ARRAY_PARAM( 2, buffer0, TraceReader::TEXT_INT);
    TR.skipLine();
    CHECK_USER_CALL(glUniform3uivEXT)
        UCT.glUniform3uivEXT(param[0].v32bit, param[1].v32bit, (const GLuint *)param[2].ptr);
    CHECK_GL_CALL(glUniform3uivEXT)
        JT.glUniform3uivEXT(param[0].v32bit, param[1].v32bit, (const GLuint *)param[2].ptr);
}

void STUB_glUniform4f( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glUniform4f( GLint, GLfloat, GLfloat, GLfloat, GLfloat )
    maxParam = 5;
    READ_PARAM(v32bit,0);
    READ_PARAM(fv32bit,1);
    READ_PARAM(fv32bit,2);
    READ_PARAM(fv32bit,3);
    READ_PARAM(fv32bit,4);
    TR.skipLine();
    CHECK_USER_CALL(glUniform4f)
        UCT.glUniform4f(param[0].v32bit, param[1].fv32bit, param[2].fv32bit, param[3].fv32bit, param[4].fv32bit);
    CHECK_GL_CALL(glUniform4f)
        JT.glUniform4f(param[0].v32bit, param[1].fv32bit, param[2].fv32bit, param[3].fv32bit, param[4].fv32bit);
}

void STUB_glUniform4fARB( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glUniform4fARB( GLint, GLfloat, GLfloat, GLfloat, GLfloat )
    maxParam = 5;
    READ_PARAM(v32bit,0);
    READ_PARAM(fv32bit,1);
    READ_PARAM(fv32bit,2);
    READ_PARAM(fv32bit,3);
    READ_PARAM(fv32bit,4);
    TR.skipLine();
    CHECK_USER_CALL(glUniform4fARB)
        UCT.glUniform4fARB(param[0].v32bit, param[1].fv32bit, param[2].fv32bit, param[3].fv32bit, param[4].fv32bit);
    CHECK_GL_CALL(glUniform4fARB)
        JT.glUniform4fARB(param[0].v32bit, param[1].fv32bit, param[2].fv32bit, param[3].fv32bit, param[4].fv32bit);
}

void STUB_glUniform4fv( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glUniform4fv( GLint, GLsizei, const GLfloat * )
    maxParam = 3;
    char buffer0[16*4096];
    READ_PARAM(v32bit,0);
    READ_PARAM(v32bit,1);
    READ_ARRAY_PARAM( 2, buffer0, TraceReader::TEXT_FLOAT);
    TR.skipLine();
    CHECK_USER_CALL(glUniform4fv)
        UCT.glUniform4fv(param[0].v32bit, param[1].v32bit, (const GLfloat *)param[2].ptr);
    CHECK_GL_CALL(glUniform4fv)
        JT.glUniform4fv(param[0].v32bit, param[1].v32bit, (const GLfloat *)param[2].ptr);
}

void STUB_glUniform4fvARB( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glUniform4fvARB( GLint, GLsizei, const GLfloat * )
    maxParam = 3;
    char buffer0[16*4096];
    READ_PARAM(v32bit,0);
    READ_PARAM(v32bit,1);
    READ_ARRAY_PARAM( 2, buffer0, TraceReader::TEXT_FLOAT);
    TR.skipLine();
    CHECK_USER_CALL(glUniform4fvARB)
        UCT.glUniform4fvARB(param[0].v32bit, param[1].v32bit, (const GLfloat *)param[2].ptr);
    CHECK_GL_CALL(glUniform4fvARB)
        JT.glUniform4fvARB(param[0].v32bit, param[1].v32bit, (const GLfloat *)param[2].ptr);
}

void STUB_glUniform4i( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glUniform4i( GLint, GLint, GLint, GLint, GLint )
    maxParam = 5;
    READ_PARAM(v32bit,0);
    READ_PARAM(v32bit,1);
    READ_PARAM(v32bit,2);
    READ_PARAM(v32bit,3);
    READ_PARAM(v32bit,4);
    TR.skipLine();
    CHECK_USER_CALL(glUniform4i)
        UCT.glUniform4i(param[0].v32bit, param[1].v32bit, param[2].v32bit, param[3].v32bit, param[4].v32bit);
    CHECK_GL_CALL(glUniform4i)
        JT.glUniform4i(param[0].v32bit, param[1].v32bit, param[2].v32bit, param[3].v32bit, param[4].v32bit);
}

void STUB_glUniform4iARB( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glUniform4iARB( GLint, GLint, GLint, GLint, GLint )
    maxParam = 5;
    READ_PARAM(v32bit,0);
    READ_PARAM(v32bit,1);
    READ_PARAM(v32bit,2);
    READ_PARAM(v32bit,3);
    READ_PARAM(v32bit,4);
    TR.skipLine();
    CHECK_USER_CALL(glUniform4iARB)
        UCT.glUniform4iARB(param[0].v32bit, param[1].v32bit, param[2].v32bit, param[3].v32bit, param[4].v32bit);
    CHECK_GL_CALL(glUniform4iARB)
        JT.glUniform4iARB(param[0].v32bit, param[1].v32bit, param[2].v32bit, param[3].v32bit, param[4].v32bit);
}

void STUB_glUniform4iv( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glUniform4iv( GLint, GLsizei, const GLint * )
    maxParam = 3;
    char buffer0[16*4096];
    READ_PARAM(v32bit,0);
    READ_PARAM(v32bit,1);
    READ_ARRAY_PARAM( 2, buffer0, TraceReader::TEXT_INT);
    TR.skipLine();
    CHECK_USER_CALL(glUniform4iv)
        UCT.glUniform4iv(param[0].v32bit, param[1].v32bit, (const GLint *)param[2].ptr);
    CHECK_GL_CALL(glUniform4iv)
        JT.glUniform4iv(param[0].v32bit, param[1].v32bit, (const GLint *)param[2].ptr);
}

void STUB_glUniform4ivARB( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glUniform4ivARB( GLint, GLsizei, const GLint * )
    maxParam = 3;
    char buffer0[16*4096];
    READ_PARAM(v32bit,0);
    READ_PARAM(v32bit,1);
    READ_ARRAY_PARAM( 2, buffer0, TraceReader::TEXT_INT);
    TR.skipLine();
    CHECK_USER_CALL(glUniform4ivARB)
        UCT.glUniform4ivARB(param[0].v32bit, param[1].v32bit, (const GLint *)param[2].ptr);
    CHECK_GL_CALL(glUniform4ivARB)
        JT.glUniform4ivARB(param[0].v32bit, param[1].v32bit, (const GLint *)param[2].ptr);
}

void STUB_glUniform4ui( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glUniform4ui( GLint, GLuint, GLuint, GLuint, GLuint )
    maxParam = 5;
    READ_PARAM(v32bit,0);
    READ_ENUM_PARAM(1);
    READ_ENUM_PARAM(2);
    READ_ENUM_PARAM(3);
    READ_ENUM_PARAM(4);
    TR.skipLine();
    CHECK_USER_CALL(glUniform4ui)
        UCT.glUniform4ui(param[0].v32bit, param[1].uv32bit, param[2].uv32bit, param[3].uv32bit, param[4].uv32bit);
    CHECK_GL_CALL(glUniform4ui)
        JT.glUniform4ui(param[0].v32bit, param[1].uv32bit, param[2].uv32bit, param[3].uv32bit, param[4].uv32bit);
}

void STUB_glUniform4uiEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glUniform4uiEXT( GLint, GLuint, GLuint, GLuint, GLuint )
    maxParam = 5;
    READ_PARAM(v32bit,0);
    READ_ENUM_PARAM(1);
    READ_ENUM_PARAM(2);
    READ_ENUM_PARAM(3);
    READ_ENUM_PARAM(4);
    TR.skipLine();
    CHECK_USER_CALL(glUniform4uiEXT)
        UCT.glUniform4uiEXT(param[0].v32bit, param[1].uv32bit, param[2].uv32bit, param[3].uv32bit, param[4].uv32bit);
    CHECK_GL_CALL(glUniform4uiEXT)
        JT.glUniform4uiEXT(param[0].v32bit, param[1].uv32bit, param[2].uv32bit, param[3].uv32bit, param[4].uv32bit);
}

void STUB_glUniform4uiv( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glUniform4uiv( GLint, GLsizei, const GLuint * )
    maxParam = 3;
    char buffer0[16*4096];
    READ_PARAM(v32bit,0);
    READ_PARAM(v32bit,1);
    READ_ARRAY_PARAM( 2, buffer0, TraceReader::TEXT_INT);
    TR.skipLine();
    CHECK_USER_CALL(glUniform4uiv)
        UCT.glUniform4uiv(param[0].v32bit, param[1].v32bit, (const GLuint *)param[2].ptr);
    CHECK_GL_CALL(glUniform4uiv)
        JT.glUniform4uiv(param[0].v32bit, param[1].v32bit, (const GLuint *)param[2].ptr);
}

void STUB_glUniform4uivEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glUniform4uivEXT( GLint, GLsizei, const GLuint * )
    maxParam = 3;
    char buffer0[16*4096];
    READ_PARAM(v32bit,0);
    READ_PARAM(v32bit,1);
    READ_ARRAY_PARAM( 2, buffer0, TraceReader::TEXT_INT);
    TR.skipLine();
    CHECK_USER_CALL(glUniform4uivEXT)
        UCT.glUniform4uivEXT(param[0].v32bit, param[1].v32bit, (const GLuint *)param[2].ptr);
    CHECK_GL_CALL(glUniform4uivEXT)
        JT.glUniform4uivEXT(param[0].v32bit, param[1].v32bit, (const GLuint *)param[2].ptr);
}

void STUB_glUniformBlockBinding( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glUniformBlockBinding( GLuint, GLuint, GLuint )
    maxParam = 3;
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_ENUM_PARAM(2);
    TR.skipLine();
    CHECK_USER_CALL(glUniformBlockBinding)
        UCT.glUniformBlockBinding(param[0].uv32bit, param[1].uv32bit, param[2].uv32bit);
    CHECK_GL_CALL(glUniformBlockBinding)
        JT.glUniformBlockBinding(param[0].uv32bit, param[1].uv32bit, param[2].uv32bit);
}

void STUB_glUniformBufferEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glUniformBufferEXT( GLuint, GLint, GLuint )
    maxParam = 3;
    READ_ENUM_PARAM(0);
    READ_PARAM(v32bit,1);
    READ_ENUM_PARAM(2);
    TR.skipLine();
    CHECK_USER_CALL(glUniformBufferEXT)
        UCT.glUniformBufferEXT(param[0].uv32bit, param[1].v32bit, param[2].uv32bit);
    CHECK_GL_CALL(glUniformBufferEXT)
        JT.glUniformBufferEXT(param[0].uv32bit, param[1].v32bit, param[2].uv32bit);
}

void STUB_glUniformMatrix2fv( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glUniformMatrix2fv( GLint, GLsizei, GLboolean, const GLfloat * )
    maxParam = 4;
    char buffer0[16*4096];
    READ_PARAM(v32bit,0);
    READ_PARAM(v32bit,1);
    READ_BOOLEAN_PARAM(2);
    READ_ARRAY_PARAM( 3, buffer0, TraceReader::TEXT_FLOAT);
    TR.skipLine();
    CHECK_USER_CALL(glUniformMatrix2fv)
        UCT.glUniformMatrix2fv(param[0].v32bit, param[1].v32bit, param[2].boolean, (const GLfloat *)param[3].ptr);
    CHECK_GL_CALL(glUniformMatrix2fv)
        JT.glUniformMatrix2fv(param[0].v32bit, param[1].v32bit, param[2].boolean, (const GLfloat *)param[3].ptr);
}

void STUB_glUniformMatrix2fvARB( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glUniformMatrix2fvARB( GLint, GLsizei, GLboolean, const GLfloat * )
    maxParam = 4;
    char buffer0[16*4096];
    READ_PARAM(v32bit,0);
    READ_PARAM(v32bit,1);
    READ_BOOLEAN_PARAM(2);
    READ_ARRAY_PARAM( 3, buffer0, TraceReader::TEXT_FLOAT);
    TR.skipLine();
    CHECK_USER_CALL(glUniformMatrix2fvARB)
        UCT.glUniformMatrix2fvARB(param[0].v32bit, param[1].v32bit, param[2].boolean, (const GLfloat *)param[3].ptr);
    CHECK_GL_CALL(glUniformMatrix2fvARB)
        JT.glUniformMatrix2fvARB(param[0].v32bit, param[1].v32bit, param[2].boolean, (const GLfloat *)param[3].ptr);
}

void STUB_glUniformMatrix2x3fv( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glUniformMatrix2x3fv( GLint, GLsizei, GLboolean, const GLfloat * )
    maxParam = 4;
    char buffer0[16*4096];
    READ_PARAM(v32bit,0);
    READ_PARAM(v32bit,1);
    READ_BOOLEAN_PARAM(2);
    READ_ARRAY_PARAM( 3, buffer0, TraceReader::TEXT_FLOAT);
    TR.skipLine();
    CHECK_USER_CALL(glUniformMatrix2x3fv)
        UCT.glUniformMatrix2x3fv(param[0].v32bit, param[1].v32bit, param[2].boolean, (const GLfloat *)param[3].ptr);
    CHECK_GL_CALL(glUniformMatrix2x3fv)
        JT.glUniformMatrix2x3fv(param[0].v32bit, param[1].v32bit, param[2].boolean, (const GLfloat *)param[3].ptr);
}

void STUB_glUniformMatrix2x4fv( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glUniformMatrix2x4fv( GLint, GLsizei, GLboolean, const GLfloat * )
    maxParam = 4;
    char buffer0[16*4096];
    READ_PARAM(v32bit,0);
    READ_PARAM(v32bit,1);
    READ_BOOLEAN_PARAM(2);
    READ_ARRAY_PARAM( 3, buffer0, TraceReader::TEXT_FLOAT);
    TR.skipLine();
    CHECK_USER_CALL(glUniformMatrix2x4fv)
        UCT.glUniformMatrix2x4fv(param[0].v32bit, param[1].v32bit, param[2].boolean, (const GLfloat *)param[3].ptr);
    CHECK_GL_CALL(glUniformMatrix2x4fv)
        JT.glUniformMatrix2x4fv(param[0].v32bit, param[1].v32bit, param[2].boolean, (const GLfloat *)param[3].ptr);
}

void STUB_glUniformMatrix3fv( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glUniformMatrix3fv( GLint, GLsizei, GLboolean, const GLfloat * )
    maxParam = 4;
    char buffer0[16*4096];
    READ_PARAM(v32bit,0);
    READ_PARAM(v32bit,1);
    READ_BOOLEAN_PARAM(2);
    READ_ARRAY_PARAM( 3, buffer0, TraceReader::TEXT_FLOAT);
    TR.skipLine();
    CHECK_USER_CALL(glUniformMatrix3fv)
        UCT.glUniformMatrix3fv(param[0].v32bit, param[1].v32bit, param[2].boolean, (const GLfloat *)param[3].ptr);
    CHECK_GL_CALL(glUniformMatrix3fv)
        JT.glUniformMatrix3fv(param[0].v32bit, param[1].v32bit, param[2].boolean, (const GLfloat *)param[3].ptr);
}

void STUB_glUniformMatrix3fvARB( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glUniformMatrix3fvARB( GLint, GLsizei, GLboolean, const GLfloat * )
    maxParam = 4;
    char buffer0[16*4096];
    READ_PARAM(v32bit,0);
    READ_PARAM(v32bit,1);
    READ_BOOLEAN_PARAM(2);
    READ_ARRAY_PARAM( 3, buffer0, TraceReader::TEXT_FLOAT);
    TR.skipLine();
    CHECK_USER_CALL(glUniformMatrix3fvARB)
        UCT.glUniformMatrix3fvARB(param[0].v32bit, param[1].v32bit, param[2].boolean, (const GLfloat *)param[3].ptr);
    CHECK_GL_CALL(glUniformMatrix3fvARB)
        JT.glUniformMatrix3fvARB(param[0].v32bit, param[1].v32bit, param[2].boolean, (const GLfloat *)param[3].ptr);
}

void STUB_glUniformMatrix3x2fv( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glUniformMatrix3x2fv( GLint, GLsizei, GLboolean, const GLfloat * )
    maxParam = 4;
    char buffer0[16*4096];
    READ_PARAM(v32bit,0);
    READ_PARAM(v32bit,1);
    READ_BOOLEAN_PARAM(2);
    READ_ARRAY_PARAM( 3, buffer0, TraceReader::TEXT_FLOAT);
    TR.skipLine();
    CHECK_USER_CALL(glUniformMatrix3x2fv)
        UCT.glUniformMatrix3x2fv(param[0].v32bit, param[1].v32bit, param[2].boolean, (const GLfloat *)param[3].ptr);
    CHECK_GL_CALL(glUniformMatrix3x2fv)
        JT.glUniformMatrix3x2fv(param[0].v32bit, param[1].v32bit, param[2].boolean, (const GLfloat *)param[3].ptr);
}

void STUB_glUniformMatrix3x4fv( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glUniformMatrix3x4fv( GLint, GLsizei, GLboolean, const GLfloat * )
    maxParam = 4;
    char buffer0[16*4096];
    READ_PARAM(v32bit,0);
    READ_PARAM(v32bit,1);
    READ_BOOLEAN_PARAM(2);
    READ_ARRAY_PARAM( 3, buffer0, TraceReader::TEXT_FLOAT);
    TR.skipLine();
    CHECK_USER_CALL(glUniformMatrix3x4fv)
        UCT.glUniformMatrix3x4fv(param[0].v32bit, param[1].v32bit, param[2].boolean, (const GLfloat *)param[3].ptr);
    CHECK_GL_CALL(glUniformMatrix3x4fv)
        JT.glUniformMatrix3x4fv(param[0].v32bit, param[1].v32bit, param[2].boolean, (const GLfloat *)param[3].ptr);
}

void STUB_glUniformMatrix4fv( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glUniformMatrix4fv( GLint, GLsizei, GLboolean, const GLfloat * )
    maxParam = 4;
    char buffer0[16*4096];
    READ_PARAM(v32bit,0);
    READ_PARAM(v32bit,1);
    READ_BOOLEAN_PARAM(2);
    READ_ARRAY_PARAM( 3, buffer0, TraceReader::TEXT_FLOAT);
    TR.skipLine();
    CHECK_USER_CALL(glUniformMatrix4fv)
        UCT.glUniformMatrix4fv(param[0].v32bit, param[1].v32bit, param[2].boolean, (const GLfloat *)param[3].ptr);
    CHECK_GL_CALL(glUniformMatrix4fv)
        JT.glUniformMatrix4fv(param[0].v32bit, param[1].v32bit, param[2].boolean, (const GLfloat *)param[3].ptr);
}

void STUB_glUniformMatrix4fvARB( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glUniformMatrix4fvARB( GLint, GLsizei, GLboolean, const GLfloat * )
    maxParam = 4;
    char buffer0[16*4096];
    READ_PARAM(v32bit,0);
    READ_PARAM(v32bit,1);
    READ_BOOLEAN_PARAM(2);
    READ_ARRAY_PARAM( 3, buffer0, TraceReader::TEXT_FLOAT);
    TR.skipLine();
    CHECK_USER_CALL(glUniformMatrix4fvARB)
        UCT.glUniformMatrix4fvARB(param[0].v32bit, param[1].v32bit, param[2].boolean, (const GLfloat *)param[3].ptr);
    CHECK_GL_CALL(glUniformMatrix4fvARB)
        JT.glUniformMatrix4fvARB(param[0].v32bit, param[1].v32bit, param[2].boolean, (const GLfloat *)param[3].ptr);
}

void STUB_glUniformMatrix4x2fv( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glUniformMatrix4x2fv( GLint, GLsizei, GLboolean, const GLfloat * )
    maxParam = 4;
    char buffer0[16*4096];
    READ_PARAM(v32bit,0);
    READ_PARAM(v32bit,1);
    READ_BOOLEAN_PARAM(2);
    READ_ARRAY_PARAM( 3, buffer0, TraceReader::TEXT_FLOAT);
    TR.skipLine();
    CHECK_USER_CALL(glUniformMatrix4x2fv)
        UCT.glUniformMatrix4x2fv(param[0].v32bit, param[1].v32bit, param[2].boolean, (const GLfloat *)param[3].ptr);
    CHECK_GL_CALL(glUniformMatrix4x2fv)
        JT.glUniformMatrix4x2fv(param[0].v32bit, param[1].v32bit, param[2].boolean, (const GLfloat *)param[3].ptr);
}

void STUB_glUniformMatrix4x3fv( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glUniformMatrix4x3fv( GLint, GLsizei, GLboolean, const GLfloat * )
    maxParam = 4;
    char buffer0[16*4096];
    READ_PARAM(v32bit,0);
    READ_PARAM(v32bit,1);
    READ_BOOLEAN_PARAM(2);
    READ_ARRAY_PARAM( 3, buffer0, TraceReader::TEXT_FLOAT);
    TR.skipLine();
    CHECK_USER_CALL(glUniformMatrix4x3fv)
        UCT.glUniformMatrix4x3fv(param[0].v32bit, param[1].v32bit, param[2].boolean, (const GLfloat *)param[3].ptr);
    CHECK_GL_CALL(glUniformMatrix4x3fv)
        JT.glUniformMatrix4x3fv(param[0].v32bit, param[1].v32bit, param[2].boolean, (const GLfloat *)param[3].ptr);
}

void STUB_glUnlockArraysEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glUnlockArraysEXT(  )
    maxParam = 0;
    TR.skipLine();
    CHECK_USER_CALL(glUnlockArraysEXT)
        UCT.glUnlockArraysEXT();
    CHECK_GL_CALL(glUnlockArraysEXT)
        JT.glUnlockArraysEXT();
}

void STUB_glUnmapBuffer( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // GLboolean glUnmapBuffer( GLenum )
    maxParam = 1;
    READ_ENUM_PARAM(0);
    TR.skipResult();
    TR.skipLine();
    CHECK_USER_CALL(glUnmapBuffer)
        UCT.glUnmapBuffer(param[0].uv32bit);
    CHECK_GL_CALL(glUnmapBuffer)
        JT.glUnmapBuffer(param[0].uv32bit);
}

void STUB_glUnmapBufferARB( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // GLboolean glUnmapBufferARB( GLenum )
    maxParam = 1;
    READ_ENUM_PARAM(0);
    TR.skipResult();
    TR.skipLine();
    CHECK_USER_CALL(glUnmapBufferARB)
        UCT.glUnmapBufferARB(param[0].uv32bit);
    CHECK_GL_CALL(glUnmapBufferARB)
        JT.glUnmapBufferARB(param[0].uv32bit);
}

void STUB_glUnmapNamedBufferEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // GLboolean glUnmapNamedBufferEXT( GLuint )
    maxParam = 1;
    READ_ENUM_PARAM(0);
    TR.skipResult();
    TR.skipLine();
    CHECK_USER_CALL(glUnmapNamedBufferEXT)
        UCT.glUnmapNamedBufferEXT(param[0].uv32bit);
    CHECK_GL_CALL(glUnmapNamedBufferEXT)
        JT.glUnmapNamedBufferEXT(param[0].uv32bit);
}

void STUB_glUnmapObjectBufferATI( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glUnmapObjectBufferATI( GLuint )
    maxParam = 1;
    READ_ENUM_PARAM(0);
    TR.skipLine();
    CHECK_USER_CALL(glUnmapObjectBufferATI)
        UCT.glUnmapObjectBufferATI(param[0].uv32bit);
    CHECK_GL_CALL(glUnmapObjectBufferATI)
        JT.glUnmapObjectBufferATI(param[0].uv32bit);
}

void STUB_glUpdateObjectBufferATI( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glUpdateObjectBufferATI( GLuint, GLuint, GLsizei, const GLvoid *, GLenum )
    maxParam = 5;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_PARAM(v32bit,2);
    READ_ARRAY_PARAM( 3, buffer0, TraceReader::TEXT_IGNORE);
    READ_ENUM_PARAM(4);
    TR.skipLine();
    CHECK_USER_CALL(glUpdateObjectBufferATI)
        UCT.glUpdateObjectBufferATI(param[0].uv32bit, param[1].uv32bit, param[2].v32bit, (const GLvoid *)param[3].ptr, param[4].uv32bit);
    CHECK_GL_CALL(glUpdateObjectBufferATI)
        JT.glUpdateObjectBufferATI(param[0].uv32bit, param[1].uv32bit, param[2].v32bit, (const GLvoid *)param[3].ptr, param[4].uv32bit);
}

void STUB_glUseProgram( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glUseProgram( GLuint )
    maxParam = 1;
    READ_ENUM_PARAM(0);
    TR.skipLine();
    CHECK_USER_CALL(glUseProgram)
        UCT.glUseProgram(param[0].uv32bit);
    CHECK_GL_CALL(glUseProgram)
        JT.glUseProgram(param[0].uv32bit);
}

void STUB_glUseProgramObjectARB( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glUseProgramObjectARB( GLhandleARB )
    maxParam = 1;
    READ_ENUM_PARAM(0);
    TR.skipLine();
    CHECK_USER_CALL(glUseProgramObjectARB)
        UCT.glUseProgramObjectARB(param[0].uv32bit);
    CHECK_GL_CALL(glUseProgramObjectARB)
        JT.glUseProgramObjectARB(param[0].uv32bit);
}

void STUB_glValidateProgram( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glValidateProgram( GLuint )
    maxParam = 1;
    READ_ENUM_PARAM(0);
    TR.skipLine();
    CHECK_USER_CALL(glValidateProgram)
        UCT.glValidateProgram(param[0].uv32bit);
    CHECK_GL_CALL(glValidateProgram)
        JT.glValidateProgram(param[0].uv32bit);
}

void STUB_glValidateProgramARB( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glValidateProgramARB( GLhandleARB )
    maxParam = 1;
    READ_ENUM_PARAM(0);
    TR.skipLine();
    CHECK_USER_CALL(glValidateProgramARB)
        UCT.glValidateProgramARB(param[0].uv32bit);
    CHECK_GL_CALL(glValidateProgramARB)
        JT.glValidateProgramARB(param[0].uv32bit);
}

void STUB_glVariantArrayObjectATI( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glVariantArrayObjectATI( GLuint, GLenum, GLsizei, GLuint, GLuint )
    maxParam = 5;
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_PARAM(v32bit,2);
    READ_ENUM_PARAM(3);
    READ_ENUM_PARAM(4);
    TR.skipLine();
    CHECK_USER_CALL(glVariantArrayObjectATI)
        UCT.glVariantArrayObjectATI(param[0].uv32bit, param[1].uv32bit, param[2].v32bit, param[3].uv32bit, param[4].uv32bit);
    CHECK_GL_CALL(glVariantArrayObjectATI)
        JT.glVariantArrayObjectATI(param[0].uv32bit, param[1].uv32bit, param[2].v32bit, param[3].uv32bit, param[4].uv32bit);
}

void STUB_glVariantPointerEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glVariantPointerEXT( GLuint, GLenum, GLuint, const GLvoid * )
    maxParam = 4;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_ENUM_PARAM(2);
    READ_ARRAY_PARAM( 3, buffer0, TraceReader::TEXT_IGNORE);
    TR.skipLine();
    CHECK_USER_CALL(glVariantPointerEXT)
        UCT.glVariantPointerEXT(param[0].uv32bit, param[1].uv32bit, param[2].uv32bit, (const GLvoid *)param[3].ptr);
    CHECK_GL_CALL(glVariantPointerEXT)
        JT.glVariantPointerEXT(param[0].uv32bit, param[1].uv32bit, param[2].uv32bit, (const GLvoid *)param[3].ptr);
}

void STUB_glVariantbvEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glVariantbvEXT( GLuint, const GLbyte * )
    maxParam = 2;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ARRAY_PARAM( 1, buffer0, TraceReader::TEXT_BYTE);
    TR.skipLine();
    CHECK_USER_CALL(glVariantbvEXT)
        UCT.glVariantbvEXT(param[0].uv32bit, (const GLbyte *)param[1].ptr);
    CHECK_GL_CALL(glVariantbvEXT)
        JT.glVariantbvEXT(param[0].uv32bit, (const GLbyte *)param[1].ptr);
}

void STUB_glVariantdvEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glVariantdvEXT( GLuint, const GLdouble * )
    maxParam = 2;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ARRAY_PARAM( 1, buffer0, TraceReader::TEXT_DOUBLE);
    TR.skipLine();
    CHECK_USER_CALL(glVariantdvEXT)
        UCT.glVariantdvEXT(param[0].uv32bit, (const GLdouble *)param[1].ptr);
    CHECK_GL_CALL(glVariantdvEXT)
        JT.glVariantdvEXT(param[0].uv32bit, (const GLdouble *)param[1].ptr);
}

void STUB_glVariantfvEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glVariantfvEXT( GLuint, const GLfloat * )
    maxParam = 2;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ARRAY_PARAM( 1, buffer0, TraceReader::TEXT_FLOAT);
    TR.skipLine();
    CHECK_USER_CALL(glVariantfvEXT)
        UCT.glVariantfvEXT(param[0].uv32bit, (const GLfloat *)param[1].ptr);
    CHECK_GL_CALL(glVariantfvEXT)
        JT.glVariantfvEXT(param[0].uv32bit, (const GLfloat *)param[1].ptr);
}

void STUB_glVariantivEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glVariantivEXT( GLuint, const GLint * )
    maxParam = 2;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ARRAY_PARAM( 1, buffer0, TraceReader::TEXT_INT);
    TR.skipLine();
    CHECK_USER_CALL(glVariantivEXT)
        UCT.glVariantivEXT(param[0].uv32bit, (const GLint *)param[1].ptr);
    CHECK_GL_CALL(glVariantivEXT)
        JT.glVariantivEXT(param[0].uv32bit, (const GLint *)param[1].ptr);
}

void STUB_glVariantsvEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glVariantsvEXT( GLuint, const GLshort * )
    maxParam = 2;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ARRAY_PARAM( 1, buffer0, TraceReader::TEXT_SHORT);
    TR.skipLine();
    CHECK_USER_CALL(glVariantsvEXT)
        UCT.glVariantsvEXT(param[0].uv32bit, (const GLshort *)param[1].ptr);
    CHECK_GL_CALL(glVariantsvEXT)
        JT.glVariantsvEXT(param[0].uv32bit, (const GLshort *)param[1].ptr);
}

void STUB_glVariantubvEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glVariantubvEXT( GLuint, const GLubyte * )
    maxParam = 2;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ARRAY_PARAM( 1, buffer0, TraceReader::TEXT_BYTE);
    TR.skipLine();
    CHECK_USER_CALL(glVariantubvEXT)
        UCT.glVariantubvEXT(param[0].uv32bit, (const GLubyte *)param[1].ptr);
    CHECK_GL_CALL(glVariantubvEXT)
        JT.glVariantubvEXT(param[0].uv32bit, (const GLubyte *)param[1].ptr);
}

void STUB_glVariantuivEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glVariantuivEXT( GLuint, const GLuint * )
    maxParam = 2;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ARRAY_PARAM( 1, buffer0, TraceReader::TEXT_INT);
    TR.skipLine();
    CHECK_USER_CALL(glVariantuivEXT)
        UCT.glVariantuivEXT(param[0].uv32bit, (const GLuint *)param[1].ptr);
    CHECK_GL_CALL(glVariantuivEXT)
        JT.glVariantuivEXT(param[0].uv32bit, (const GLuint *)param[1].ptr);
}

void STUB_glVariantusvEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glVariantusvEXT( GLuint, const GLushort * )
    maxParam = 2;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ARRAY_PARAM( 1, buffer0, TraceReader::TEXT_SHORT);
    TR.skipLine();
    CHECK_USER_CALL(glVariantusvEXT)
        UCT.glVariantusvEXT(param[0].uv32bit, (const GLushort *)param[1].ptr);
    CHECK_GL_CALL(glVariantusvEXT)
        JT.glVariantusvEXT(param[0].uv32bit, (const GLushort *)param[1].ptr);
}

void STUB_glVertex2d( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glVertex2d( GLdouble x, GLdouble y )
    maxParam = 2;
    READ_DOUBLE_PARAM(0);
    READ_DOUBLE_PARAM(1);
    TR.skipLine();
    CHECK_USER_CALL(glVertex2d)
        UCT.glVertex2d(param[0].fv64bit, param[1].fv64bit);
    CHECK_GL_CALL(glVertex2d)
        JT.glVertex2d(param[0].fv64bit, param[1].fv64bit);
}

void STUB_glVertex2dv( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glVertex2dv( const GLdouble *v )
    maxParam = 1;
    char buffer0[16*4096];
    READ_ARRAY_PARAM( 0, buffer0, TraceReader::TEXT_DOUBLE);
    TR.skipLine();
    CHECK_USER_CALL(glVertex2dv)
        UCT.glVertex2dv((const GLdouble *)param[0].ptr);
    CHECK_GL_CALL(glVertex2dv)
        JT.glVertex2dv((const GLdouble *)param[0].ptr);
}

void STUB_glVertex2f( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glVertex2f( GLfloat x, GLfloat y )
    maxParam = 2;
    READ_PARAM(fv32bit,0);
    READ_PARAM(fv32bit,1);
    TR.skipLine();
    CHECK_USER_CALL(glVertex2f)
        UCT.glVertex2f(param[0].fv32bit, param[1].fv32bit);
    CHECK_GL_CALL(glVertex2f)
        JT.glVertex2f(param[0].fv32bit, param[1].fv32bit);
}

void STUB_glVertex2fv( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glVertex2fv( const GLfloat *v )
    maxParam = 1;
    char buffer0[16*4096];
    READ_ARRAY_PARAM( 0, buffer0, TraceReader::TEXT_FLOAT);
    TR.skipLine();
    CHECK_USER_CALL(glVertex2fv)
        UCT.glVertex2fv((const GLfloat *)param[0].ptr);
    CHECK_GL_CALL(glVertex2fv)
        JT.glVertex2fv((const GLfloat *)param[0].ptr);
}

void STUB_glVertex2hNV( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glVertex2hNV( GLhalfNV, GLhalfNV )
    // Call not playable
    TR.skipCall();
}

void STUB_glVertex2hvNV( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glVertex2hvNV( const GLhalfNV * )
    // Call not playable
    TR.skipCall();
}

void STUB_glVertex2i( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glVertex2i( GLint x, GLint y )
    maxParam = 2;
    READ_PARAM(v32bit,0);
    READ_PARAM(v32bit,1);
    TR.skipLine();
    CHECK_USER_CALL(glVertex2i)
        UCT.glVertex2i(param[0].v32bit, param[1].v32bit);
    CHECK_GL_CALL(glVertex2i)
        JT.glVertex2i(param[0].v32bit, param[1].v32bit);
}

void STUB_glVertex2iv( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glVertex2iv( const GLint *v )
    maxParam = 1;
    char buffer0[16*4096];
    READ_ARRAY_PARAM( 0, buffer0, TraceReader::TEXT_INT);
    TR.skipLine();
    CHECK_USER_CALL(glVertex2iv)
        UCT.glVertex2iv((const GLint *)param[0].ptr);
    CHECK_GL_CALL(glVertex2iv)
        JT.glVertex2iv((const GLint *)param[0].ptr);
}

void STUB_glVertex2s( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glVertex2s( GLshort x, GLshort y )
    maxParam = 2;
    READ_PARAM(v16bit,0);
    READ_PARAM(v16bit,1);
    TR.skipLine();
    CHECK_USER_CALL(glVertex2s)
        UCT.glVertex2s(param[0].v16bit, param[1].v16bit);
    CHECK_GL_CALL(glVertex2s)
        JT.glVertex2s(param[0].v16bit, param[1].v16bit);
}

void STUB_glVertex2sv( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glVertex2sv( const GLshort *v )
    maxParam = 1;
    char buffer0[16*4096];
    READ_ARRAY_PARAM( 0, buffer0, TraceReader::TEXT_SHORT);
    TR.skipLine();
    CHECK_USER_CALL(glVertex2sv)
        UCT.glVertex2sv((const GLshort *)param[0].ptr);
    CHECK_GL_CALL(glVertex2sv)
        JT.glVertex2sv((const GLshort *)param[0].ptr);
}

void STUB_glVertex3d( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glVertex3d( GLdouble x, GLdouble y, GLdouble z )
    maxParam = 3;
    READ_DOUBLE_PARAM(0);
    READ_DOUBLE_PARAM(1);
    READ_DOUBLE_PARAM(2);
    TR.skipLine();
    CHECK_USER_CALL(glVertex3d)
        UCT.glVertex3d(param[0].fv64bit, param[1].fv64bit, param[2].fv64bit);
    CHECK_GL_CALL(glVertex3d)
        JT.glVertex3d(param[0].fv64bit, param[1].fv64bit, param[2].fv64bit);
}

void STUB_glVertex3dv( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glVertex3dv( const GLdouble *v )
    maxParam = 1;
    char buffer0[16*4096];
    READ_ARRAY_PARAM( 0, buffer0, TraceReader::TEXT_DOUBLE);
    TR.skipLine();
    CHECK_USER_CALL(glVertex3dv)
        UCT.glVertex3dv((const GLdouble *)param[0].ptr);
    CHECK_GL_CALL(glVertex3dv)
        JT.glVertex3dv((const GLdouble *)param[0].ptr);
}

void STUB_glVertex3f( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glVertex3f( GLfloat x, GLfloat y, GLfloat z )
    maxParam = 3;
    READ_PARAM(fv32bit,0);
    READ_PARAM(fv32bit,1);
    READ_PARAM(fv32bit,2);
    TR.skipLine();
    CHECK_USER_CALL(glVertex3f)
        UCT.glVertex3f(param[0].fv32bit, param[1].fv32bit, param[2].fv32bit);
    CHECK_GL_CALL(glVertex3f)
        JT.glVertex3f(param[0].fv32bit, param[1].fv32bit, param[2].fv32bit);
}

void STUB_glVertex3fv( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glVertex3fv( const GLfloat *v )
    maxParam = 1;
    char buffer0[16*4096];
    READ_ARRAY_PARAM( 0, buffer0, TraceReader::TEXT_FLOAT);
    TR.skipLine();
    CHECK_USER_CALL(glVertex3fv)
        UCT.glVertex3fv((const GLfloat *)param[0].ptr);
    CHECK_GL_CALL(glVertex3fv)
        JT.glVertex3fv((const GLfloat *)param[0].ptr);
}

void STUB_glVertex3hNV( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glVertex3hNV( GLhalfNV, GLhalfNV, GLhalfNV )
    // Call not playable
    TR.skipCall();
}

void STUB_glVertex3hvNV( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glVertex3hvNV( const GLhalfNV * )
    // Call not playable
    TR.skipCall();
}

void STUB_glVertex3i( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glVertex3i( GLint x, GLint y, GLint z )
    maxParam = 3;
    READ_PARAM(v32bit,0);
    READ_PARAM(v32bit,1);
    READ_PARAM(v32bit,2);
    TR.skipLine();
    CHECK_USER_CALL(glVertex3i)
        UCT.glVertex3i(param[0].v32bit, param[1].v32bit, param[2].v32bit);
    CHECK_GL_CALL(glVertex3i)
        JT.glVertex3i(param[0].v32bit, param[1].v32bit, param[2].v32bit);
}

void STUB_glVertex3iv( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glVertex3iv( const GLint *v )
    maxParam = 1;
    char buffer0[16*4096];
    READ_ARRAY_PARAM( 0, buffer0, TraceReader::TEXT_INT);
    TR.skipLine();
    CHECK_USER_CALL(glVertex3iv)
        UCT.glVertex3iv((const GLint *)param[0].ptr);
    CHECK_GL_CALL(glVertex3iv)
        JT.glVertex3iv((const GLint *)param[0].ptr);
}

void STUB_glVertex3s( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glVertex3s( GLshort x, GLshort y, GLshort z )
    maxParam = 3;
    READ_PARAM(v16bit,0);
    READ_PARAM(v16bit,1);
    READ_PARAM(v16bit,2);
    TR.skipLine();
    CHECK_USER_CALL(glVertex3s)
        UCT.glVertex3s(param[0].v16bit, param[1].v16bit, param[2].v16bit);
    CHECK_GL_CALL(glVertex3s)
        JT.glVertex3s(param[0].v16bit, param[1].v16bit, param[2].v16bit);
}

void STUB_glVertex3sv( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glVertex3sv( const GLshort *v )
    maxParam = 1;
    char buffer0[16*4096];
    READ_ARRAY_PARAM( 0, buffer0, TraceReader::TEXT_SHORT);
    TR.skipLine();
    CHECK_USER_CALL(glVertex3sv)
        UCT.glVertex3sv((const GLshort *)param[0].ptr);
    CHECK_GL_CALL(glVertex3sv)
        JT.glVertex3sv((const GLshort *)param[0].ptr);
}

void STUB_glVertex4d( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glVertex4d( GLdouble x, GLdouble y, GLdouble z, GLdouble w )
    maxParam = 4;
    READ_DOUBLE_PARAM(0);
    READ_DOUBLE_PARAM(1);
    READ_DOUBLE_PARAM(2);
    READ_DOUBLE_PARAM(3);
    TR.skipLine();
    CHECK_USER_CALL(glVertex4d)
        UCT.glVertex4d(param[0].fv64bit, param[1].fv64bit, param[2].fv64bit, param[3].fv64bit);
    CHECK_GL_CALL(glVertex4d)
        JT.glVertex4d(param[0].fv64bit, param[1].fv64bit, param[2].fv64bit, param[3].fv64bit);
}

void STUB_glVertex4dv( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glVertex4dv( const GLdouble *v )
    maxParam = 1;
    char buffer0[16*4096];
    READ_ARRAY_PARAM( 0, buffer0, TraceReader::TEXT_DOUBLE);
    TR.skipLine();
    CHECK_USER_CALL(glVertex4dv)
        UCT.glVertex4dv((const GLdouble *)param[0].ptr);
    CHECK_GL_CALL(glVertex4dv)
        JT.glVertex4dv((const GLdouble *)param[0].ptr);
}

void STUB_glVertex4f( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glVertex4f( GLfloat x, GLfloat y, GLfloat z, GLfloat w )
    maxParam = 4;
    READ_PARAM(fv32bit,0);
    READ_PARAM(fv32bit,1);
    READ_PARAM(fv32bit,2);
    READ_PARAM(fv32bit,3);
    TR.skipLine();
    CHECK_USER_CALL(glVertex4f)
        UCT.glVertex4f(param[0].fv32bit, param[1].fv32bit, param[2].fv32bit, param[3].fv32bit);
    CHECK_GL_CALL(glVertex4f)
        JT.glVertex4f(param[0].fv32bit, param[1].fv32bit, param[2].fv32bit, param[3].fv32bit);
}

void STUB_glVertex4fv( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glVertex4fv( const GLfloat *v )
    maxParam = 1;
    char buffer0[16*4096];
    READ_ARRAY_PARAM( 0, buffer0, TraceReader::TEXT_FLOAT);
    TR.skipLine();
    CHECK_USER_CALL(glVertex4fv)
        UCT.glVertex4fv((const GLfloat *)param[0].ptr);
    CHECK_GL_CALL(glVertex4fv)
        JT.glVertex4fv((const GLfloat *)param[0].ptr);
}

void STUB_glVertex4hNV( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glVertex4hNV( GLhalfNV, GLhalfNV, GLhalfNV, GLhalfNV )
    // Call not playable
    TR.skipCall();
}

void STUB_glVertex4hvNV( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glVertex4hvNV( const GLhalfNV * )
    // Call not playable
    TR.skipCall();
}

void STUB_glVertex4i( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glVertex4i( GLint x, GLint y, GLint z, GLint w )
    maxParam = 4;
    READ_PARAM(v32bit,0);
    READ_PARAM(v32bit,1);
    READ_PARAM(v32bit,2);
    READ_PARAM(v32bit,3);
    TR.skipLine();
    CHECK_USER_CALL(glVertex4i)
        UCT.glVertex4i(param[0].v32bit, param[1].v32bit, param[2].v32bit, param[3].v32bit);
    CHECK_GL_CALL(glVertex4i)
        JT.glVertex4i(param[0].v32bit, param[1].v32bit, param[2].v32bit, param[3].v32bit);
}

void STUB_glVertex4iv( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glVertex4iv( const GLint *v )
    maxParam = 1;
    char buffer0[16*4096];
    READ_ARRAY_PARAM( 0, buffer0, TraceReader::TEXT_INT);
    TR.skipLine();
    CHECK_USER_CALL(glVertex4iv)
        UCT.glVertex4iv((const GLint *)param[0].ptr);
    CHECK_GL_CALL(glVertex4iv)
        JT.glVertex4iv((const GLint *)param[0].ptr);
}

void STUB_glVertex4s( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glVertex4s( GLshort x, GLshort y, GLshort z, GLshort w )
    maxParam = 4;
    READ_PARAM(v16bit,0);
    READ_PARAM(v16bit,1);
    READ_PARAM(v16bit,2);
    READ_PARAM(v16bit,3);
    TR.skipLine();
    CHECK_USER_CALL(glVertex4s)
        UCT.glVertex4s(param[0].v16bit, param[1].v16bit, param[2].v16bit, param[3].v16bit);
    CHECK_GL_CALL(glVertex4s)
        JT.glVertex4s(param[0].v16bit, param[1].v16bit, param[2].v16bit, param[3].v16bit);
}

void STUB_glVertex4sv( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glVertex4sv( const GLshort *v )
    maxParam = 1;
    char buffer0[16*4096];
    READ_ARRAY_PARAM( 0, buffer0, TraceReader::TEXT_SHORT);
    TR.skipLine();
    CHECK_USER_CALL(glVertex4sv)
        UCT.glVertex4sv((const GLshort *)param[0].ptr);
    CHECK_GL_CALL(glVertex4sv)
        JT.glVertex4sv((const GLshort *)param[0].ptr);
}

void STUB_glVertexArrayParameteriAPPLE( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glVertexArrayParameteriAPPLE( GLenum, GLint )
    maxParam = 2;
    READ_ENUM_PARAM(0);
    READ_PARAM(v32bit,1);
    TR.skipLine();
    CHECK_USER_CALL(glVertexArrayParameteriAPPLE)
        UCT.glVertexArrayParameteriAPPLE(param[0].uv32bit, param[1].v32bit);
    CHECK_GL_CALL(glVertexArrayParameteriAPPLE)
        JT.glVertexArrayParameteriAPPLE(param[0].uv32bit, param[1].v32bit);
}

void STUB_glVertexArrayRangeAPPLE( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glVertexArrayRangeAPPLE( GLsizei, GLvoid * )
    maxParam = 2;
    char buffer0[16*4096];
    READ_PARAM(v32bit,0);
    READ_ARRAY_PARAM( 1, buffer0, TraceReader::TEXT_IGNORE);
    TR.skipLine();
    CHECK_USER_CALL(glVertexArrayRangeAPPLE)
        UCT.glVertexArrayRangeAPPLE(param[0].v32bit, (GLvoid *)param[1].ptr);
    CHECK_GL_CALL(glVertexArrayRangeAPPLE)
        JT.glVertexArrayRangeAPPLE(param[0].v32bit, (GLvoid *)param[1].ptr);
}

void STUB_glVertexArrayRangeNV( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glVertexArrayRangeNV( GLsizei, const GLvoid * )
    maxParam = 2;
    char buffer0[16*4096];
    READ_PARAM(v32bit,0);
    READ_ARRAY_PARAM( 1, buffer0, TraceReader::TEXT_IGNORE);
    TR.skipLine();
    CHECK_USER_CALL(glVertexArrayRangeNV)
        UCT.glVertexArrayRangeNV(param[0].v32bit, (const GLvoid *)param[1].ptr);
    CHECK_GL_CALL(glVertexArrayRangeNV)
        JT.glVertexArrayRangeNV(param[0].v32bit, (const GLvoid *)param[1].ptr);
}

void STUB_glVertexAttrib1d( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glVertexAttrib1d( GLuint, GLdouble )
    maxParam = 2;
    READ_ENUM_PARAM(0);
    READ_DOUBLE_PARAM(1);
    TR.skipLine();
    CHECK_USER_CALL(glVertexAttrib1d)
        UCT.glVertexAttrib1d(param[0].uv32bit, param[1].fv64bit);
    CHECK_GL_CALL(glVertexAttrib1d)
        JT.glVertexAttrib1d(param[0].uv32bit, param[1].fv64bit);
}

void STUB_glVertexAttrib1dARB( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glVertexAttrib1dARB( GLuint, GLdouble )
    maxParam = 2;
    READ_ENUM_PARAM(0);
    READ_DOUBLE_PARAM(1);
    TR.skipLine();
    CHECK_USER_CALL(glVertexAttrib1dARB)
        UCT.glVertexAttrib1dARB(param[0].uv32bit, param[1].fv64bit);
    CHECK_GL_CALL(glVertexAttrib1dARB)
        JT.glVertexAttrib1dARB(param[0].uv32bit, param[1].fv64bit);
}

void STUB_glVertexAttrib1dNV( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glVertexAttrib1dNV( GLuint, GLdouble )
    maxParam = 2;
    READ_ENUM_PARAM(0);
    READ_DOUBLE_PARAM(1);
    TR.skipLine();
    CHECK_USER_CALL(glVertexAttrib1dNV)
        UCT.glVertexAttrib1dNV(param[0].uv32bit, param[1].fv64bit);
    CHECK_GL_CALL(glVertexAttrib1dNV)
        JT.glVertexAttrib1dNV(param[0].uv32bit, param[1].fv64bit);
}

void STUB_glVertexAttrib1dv( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glVertexAttrib1dv( GLuint, const GLdouble * )
    maxParam = 2;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ARRAY_PARAM( 1, buffer0, TraceReader::TEXT_DOUBLE);
    TR.skipLine();
    CHECK_USER_CALL(glVertexAttrib1dv)
        UCT.glVertexAttrib1dv(param[0].uv32bit, (const GLdouble *)param[1].ptr);
    CHECK_GL_CALL(glVertexAttrib1dv)
        JT.glVertexAttrib1dv(param[0].uv32bit, (const GLdouble *)param[1].ptr);
}

void STUB_glVertexAttrib1dvARB( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glVertexAttrib1dvARB( GLuint, const GLdouble * )
    maxParam = 2;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ARRAY_PARAM( 1, buffer0, TraceReader::TEXT_DOUBLE);
    TR.skipLine();
    CHECK_USER_CALL(glVertexAttrib1dvARB)
        UCT.glVertexAttrib1dvARB(param[0].uv32bit, (const GLdouble *)param[1].ptr);
    CHECK_GL_CALL(glVertexAttrib1dvARB)
        JT.glVertexAttrib1dvARB(param[0].uv32bit, (const GLdouble *)param[1].ptr);
}

void STUB_glVertexAttrib1dvNV( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glVertexAttrib1dvNV( GLuint, const GLdouble * )
    maxParam = 2;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ARRAY_PARAM( 1, buffer0, TraceReader::TEXT_DOUBLE);
    TR.skipLine();
    CHECK_USER_CALL(glVertexAttrib1dvNV)
        UCT.glVertexAttrib1dvNV(param[0].uv32bit, (const GLdouble *)param[1].ptr);
    CHECK_GL_CALL(glVertexAttrib1dvNV)
        JT.glVertexAttrib1dvNV(param[0].uv32bit, (const GLdouble *)param[1].ptr);
}

void STUB_glVertexAttrib1f( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glVertexAttrib1f( GLuint, GLfloat )
    maxParam = 2;
    READ_ENUM_PARAM(0);
    READ_PARAM(fv32bit,1);
    TR.skipLine();
    CHECK_USER_CALL(glVertexAttrib1f)
        UCT.glVertexAttrib1f(param[0].uv32bit, param[1].fv32bit);
    CHECK_GL_CALL(glVertexAttrib1f)
        JT.glVertexAttrib1f(param[0].uv32bit, param[1].fv32bit);
}

void STUB_glVertexAttrib1fARB( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glVertexAttrib1fARB( GLuint, GLfloat )
    maxParam = 2;
    READ_ENUM_PARAM(0);
    READ_PARAM(fv32bit,1);
    TR.skipLine();
    CHECK_USER_CALL(glVertexAttrib1fARB)
        UCT.glVertexAttrib1fARB(param[0].uv32bit, param[1].fv32bit);
    CHECK_GL_CALL(glVertexAttrib1fARB)
        JT.glVertexAttrib1fARB(param[0].uv32bit, param[1].fv32bit);
}

void STUB_glVertexAttrib1fNV( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glVertexAttrib1fNV( GLuint, GLfloat )
    maxParam = 2;
    READ_ENUM_PARAM(0);
    READ_PARAM(fv32bit,1);
    TR.skipLine();
    CHECK_USER_CALL(glVertexAttrib1fNV)
        UCT.glVertexAttrib1fNV(param[0].uv32bit, param[1].fv32bit);
    CHECK_GL_CALL(glVertexAttrib1fNV)
        JT.glVertexAttrib1fNV(param[0].uv32bit, param[1].fv32bit);
}

void STUB_glVertexAttrib1fv( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glVertexAttrib1fv( GLuint, const GLfloat * )
    maxParam = 2;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ARRAY_PARAM( 1, buffer0, TraceReader::TEXT_FLOAT);
    TR.skipLine();
    CHECK_USER_CALL(glVertexAttrib1fv)
        UCT.glVertexAttrib1fv(param[0].uv32bit, (const GLfloat *)param[1].ptr);
    CHECK_GL_CALL(glVertexAttrib1fv)
        JT.glVertexAttrib1fv(param[0].uv32bit, (const GLfloat *)param[1].ptr);
}

void STUB_glVertexAttrib1fvARB( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glVertexAttrib1fvARB( GLuint, const GLfloat * )
    maxParam = 2;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ARRAY_PARAM( 1, buffer0, TraceReader::TEXT_FLOAT);
    TR.skipLine();
    CHECK_USER_CALL(glVertexAttrib1fvARB)
        UCT.glVertexAttrib1fvARB(param[0].uv32bit, (const GLfloat *)param[1].ptr);
    CHECK_GL_CALL(glVertexAttrib1fvARB)
        JT.glVertexAttrib1fvARB(param[0].uv32bit, (const GLfloat *)param[1].ptr);
}

void STUB_glVertexAttrib1fvNV( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glVertexAttrib1fvNV( GLuint, const GLfloat * )
    maxParam = 2;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ARRAY_PARAM( 1, buffer0, TraceReader::TEXT_FLOAT);
    TR.skipLine();
    CHECK_USER_CALL(glVertexAttrib1fvNV)
        UCT.glVertexAttrib1fvNV(param[0].uv32bit, (const GLfloat *)param[1].ptr);
    CHECK_GL_CALL(glVertexAttrib1fvNV)
        JT.glVertexAttrib1fvNV(param[0].uv32bit, (const GLfloat *)param[1].ptr);
}

void STUB_glVertexAttrib1hNV( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glVertexAttrib1hNV( GLuint, GLhalfNV )
    // Call not playable
    TR.skipCall();
}

void STUB_glVertexAttrib1hvNV( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glVertexAttrib1hvNV( GLuint, const GLhalfNV * )
    // Call not playable
    TR.skipCall();
}

void STUB_glVertexAttrib1s( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glVertexAttrib1s( GLuint, GLshort )
    maxParam = 2;
    READ_ENUM_PARAM(0);
    READ_PARAM(v16bit,1);
    TR.skipLine();
    CHECK_USER_CALL(glVertexAttrib1s)
        UCT.glVertexAttrib1s(param[0].uv32bit, param[1].v16bit);
    CHECK_GL_CALL(glVertexAttrib1s)
        JT.glVertexAttrib1s(param[0].uv32bit, param[1].v16bit);
}

void STUB_glVertexAttrib1sARB( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glVertexAttrib1sARB( GLuint, GLshort )
    maxParam = 2;
    READ_ENUM_PARAM(0);
    READ_PARAM(v16bit,1);
    TR.skipLine();
    CHECK_USER_CALL(glVertexAttrib1sARB)
        UCT.glVertexAttrib1sARB(param[0].uv32bit, param[1].v16bit);
    CHECK_GL_CALL(glVertexAttrib1sARB)
        JT.glVertexAttrib1sARB(param[0].uv32bit, param[1].v16bit);
}

void STUB_glVertexAttrib1sNV( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glVertexAttrib1sNV( GLuint, GLshort )
    maxParam = 2;
    READ_ENUM_PARAM(0);
    READ_PARAM(v16bit,1);
    TR.skipLine();
    CHECK_USER_CALL(glVertexAttrib1sNV)
        UCT.glVertexAttrib1sNV(param[0].uv32bit, param[1].v16bit);
    CHECK_GL_CALL(glVertexAttrib1sNV)
        JT.glVertexAttrib1sNV(param[0].uv32bit, param[1].v16bit);
}

void STUB_glVertexAttrib1sv( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glVertexAttrib1sv( GLuint, const GLshort * )
    maxParam = 2;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ARRAY_PARAM( 1, buffer0, TraceReader::TEXT_SHORT);
    TR.skipLine();
    CHECK_USER_CALL(glVertexAttrib1sv)
        UCT.glVertexAttrib1sv(param[0].uv32bit, (const GLshort *)param[1].ptr);
    CHECK_GL_CALL(glVertexAttrib1sv)
        JT.glVertexAttrib1sv(param[0].uv32bit, (const GLshort *)param[1].ptr);
}

void STUB_glVertexAttrib1svARB( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glVertexAttrib1svARB( GLuint, const GLshort * )
    maxParam = 2;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ARRAY_PARAM( 1, buffer0, TraceReader::TEXT_SHORT);
    TR.skipLine();
    CHECK_USER_CALL(glVertexAttrib1svARB)
        UCT.glVertexAttrib1svARB(param[0].uv32bit, (const GLshort *)param[1].ptr);
    CHECK_GL_CALL(glVertexAttrib1svARB)
        JT.glVertexAttrib1svARB(param[0].uv32bit, (const GLshort *)param[1].ptr);
}

void STUB_glVertexAttrib1svNV( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glVertexAttrib1svNV( GLuint, const GLshort * )
    maxParam = 2;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ARRAY_PARAM( 1, buffer0, TraceReader::TEXT_SHORT);
    TR.skipLine();
    CHECK_USER_CALL(glVertexAttrib1svNV)
        UCT.glVertexAttrib1svNV(param[0].uv32bit, (const GLshort *)param[1].ptr);
    CHECK_GL_CALL(glVertexAttrib1svNV)
        JT.glVertexAttrib1svNV(param[0].uv32bit, (const GLshort *)param[1].ptr);
}

void STUB_glVertexAttrib2d( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glVertexAttrib2d( GLuint, GLdouble, GLdouble )
    maxParam = 3;
    READ_ENUM_PARAM(0);
    READ_DOUBLE_PARAM(1);
    READ_DOUBLE_PARAM(2);
    TR.skipLine();
    CHECK_USER_CALL(glVertexAttrib2d)
        UCT.glVertexAttrib2d(param[0].uv32bit, param[1].fv64bit, param[2].fv64bit);
    CHECK_GL_CALL(glVertexAttrib2d)
        JT.glVertexAttrib2d(param[0].uv32bit, param[1].fv64bit, param[2].fv64bit);
}

void STUB_glVertexAttrib2dARB( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glVertexAttrib2dARB( GLuint, GLdouble, GLdouble )
    maxParam = 3;
    READ_ENUM_PARAM(0);
    READ_DOUBLE_PARAM(1);
    READ_DOUBLE_PARAM(2);
    TR.skipLine();
    CHECK_USER_CALL(glVertexAttrib2dARB)
        UCT.glVertexAttrib2dARB(param[0].uv32bit, param[1].fv64bit, param[2].fv64bit);
    CHECK_GL_CALL(glVertexAttrib2dARB)
        JT.glVertexAttrib2dARB(param[0].uv32bit, param[1].fv64bit, param[2].fv64bit);
}

void STUB_glVertexAttrib2dNV( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glVertexAttrib2dNV( GLuint, GLdouble, GLdouble )
    maxParam = 3;
    READ_ENUM_PARAM(0);
    READ_DOUBLE_PARAM(1);
    READ_DOUBLE_PARAM(2);
    TR.skipLine();
    CHECK_USER_CALL(glVertexAttrib2dNV)
        UCT.glVertexAttrib2dNV(param[0].uv32bit, param[1].fv64bit, param[2].fv64bit);
    CHECK_GL_CALL(glVertexAttrib2dNV)
        JT.glVertexAttrib2dNV(param[0].uv32bit, param[1].fv64bit, param[2].fv64bit);
}

void STUB_glVertexAttrib2dv( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glVertexAttrib2dv( GLuint, const GLdouble * )
    maxParam = 2;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ARRAY_PARAM( 1, buffer0, TraceReader::TEXT_DOUBLE);
    TR.skipLine();
    CHECK_USER_CALL(glVertexAttrib2dv)
        UCT.glVertexAttrib2dv(param[0].uv32bit, (const GLdouble *)param[1].ptr);
    CHECK_GL_CALL(glVertexAttrib2dv)
        JT.glVertexAttrib2dv(param[0].uv32bit, (const GLdouble *)param[1].ptr);
}

void STUB_glVertexAttrib2dvARB( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glVertexAttrib2dvARB( GLuint, const GLdouble * )
    maxParam = 2;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ARRAY_PARAM( 1, buffer0, TraceReader::TEXT_DOUBLE);
    TR.skipLine();
    CHECK_USER_CALL(glVertexAttrib2dvARB)
        UCT.glVertexAttrib2dvARB(param[0].uv32bit, (const GLdouble *)param[1].ptr);
    CHECK_GL_CALL(glVertexAttrib2dvARB)
        JT.glVertexAttrib2dvARB(param[0].uv32bit, (const GLdouble *)param[1].ptr);
}

void STUB_glVertexAttrib2dvNV( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glVertexAttrib2dvNV( GLuint, const GLdouble * )
    maxParam = 2;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ARRAY_PARAM( 1, buffer0, TraceReader::TEXT_DOUBLE);
    TR.skipLine();
    CHECK_USER_CALL(glVertexAttrib2dvNV)
        UCT.glVertexAttrib2dvNV(param[0].uv32bit, (const GLdouble *)param[1].ptr);
    CHECK_GL_CALL(glVertexAttrib2dvNV)
        JT.glVertexAttrib2dvNV(param[0].uv32bit, (const GLdouble *)param[1].ptr);
}

void STUB_glVertexAttrib2f( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glVertexAttrib2f( GLuint, GLfloat, GLfloat )
    maxParam = 3;
    READ_ENUM_PARAM(0);
    READ_PARAM(fv32bit,1);
    READ_PARAM(fv32bit,2);
    TR.skipLine();
    CHECK_USER_CALL(glVertexAttrib2f)
        UCT.glVertexAttrib2f(param[0].uv32bit, param[1].fv32bit, param[2].fv32bit);
    CHECK_GL_CALL(glVertexAttrib2f)
        JT.glVertexAttrib2f(param[0].uv32bit, param[1].fv32bit, param[2].fv32bit);
}

void STUB_glVertexAttrib2fARB( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glVertexAttrib2fARB( GLuint, GLfloat, GLfloat )
    maxParam = 3;
    READ_ENUM_PARAM(0);
    READ_PARAM(fv32bit,1);
    READ_PARAM(fv32bit,2);
    TR.skipLine();
    CHECK_USER_CALL(glVertexAttrib2fARB)
        UCT.glVertexAttrib2fARB(param[0].uv32bit, param[1].fv32bit, param[2].fv32bit);
    CHECK_GL_CALL(glVertexAttrib2fARB)
        JT.glVertexAttrib2fARB(param[0].uv32bit, param[1].fv32bit, param[2].fv32bit);
}

void STUB_glVertexAttrib2fNV( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glVertexAttrib2fNV( GLuint, GLfloat, GLfloat )
    maxParam = 3;
    READ_ENUM_PARAM(0);
    READ_PARAM(fv32bit,1);
    READ_PARAM(fv32bit,2);
    TR.skipLine();
    CHECK_USER_CALL(glVertexAttrib2fNV)
        UCT.glVertexAttrib2fNV(param[0].uv32bit, param[1].fv32bit, param[2].fv32bit);
    CHECK_GL_CALL(glVertexAttrib2fNV)
        JT.glVertexAttrib2fNV(param[0].uv32bit, param[1].fv32bit, param[2].fv32bit);
}

void STUB_glVertexAttrib2fv( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glVertexAttrib2fv( GLuint, const GLfloat * )
    maxParam = 2;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ARRAY_PARAM( 1, buffer0, TraceReader::TEXT_FLOAT);
    TR.skipLine();
    CHECK_USER_CALL(glVertexAttrib2fv)
        UCT.glVertexAttrib2fv(param[0].uv32bit, (const GLfloat *)param[1].ptr);
    CHECK_GL_CALL(glVertexAttrib2fv)
        JT.glVertexAttrib2fv(param[0].uv32bit, (const GLfloat *)param[1].ptr);
}

void STUB_glVertexAttrib2fvARB( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glVertexAttrib2fvARB( GLuint, const GLfloat * )
    maxParam = 2;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ARRAY_PARAM( 1, buffer0, TraceReader::TEXT_FLOAT);
    TR.skipLine();
    CHECK_USER_CALL(glVertexAttrib2fvARB)
        UCT.glVertexAttrib2fvARB(param[0].uv32bit, (const GLfloat *)param[1].ptr);
    CHECK_GL_CALL(glVertexAttrib2fvARB)
        JT.glVertexAttrib2fvARB(param[0].uv32bit, (const GLfloat *)param[1].ptr);
}

void STUB_glVertexAttrib2fvNV( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glVertexAttrib2fvNV( GLuint, const GLfloat * )
    maxParam = 2;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ARRAY_PARAM( 1, buffer0, TraceReader::TEXT_FLOAT);
    TR.skipLine();
    CHECK_USER_CALL(glVertexAttrib2fvNV)
        UCT.glVertexAttrib2fvNV(param[0].uv32bit, (const GLfloat *)param[1].ptr);
    CHECK_GL_CALL(glVertexAttrib2fvNV)
        JT.glVertexAttrib2fvNV(param[0].uv32bit, (const GLfloat *)param[1].ptr);
}

void STUB_glVertexAttrib2hNV( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glVertexAttrib2hNV( GLuint, GLhalfNV, GLhalfNV )
    // Call not playable
    TR.skipCall();
}

void STUB_glVertexAttrib2hvNV( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glVertexAttrib2hvNV( GLuint, const GLhalfNV * )
    // Call not playable
    TR.skipCall();
}

void STUB_glVertexAttrib2s( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glVertexAttrib2s( GLuint, GLshort, GLshort )
    maxParam = 3;
    READ_ENUM_PARAM(0);
    READ_PARAM(v16bit,1);
    READ_PARAM(v16bit,2);
    TR.skipLine();
    CHECK_USER_CALL(glVertexAttrib2s)
        UCT.glVertexAttrib2s(param[0].uv32bit, param[1].v16bit, param[2].v16bit);
    CHECK_GL_CALL(glVertexAttrib2s)
        JT.glVertexAttrib2s(param[0].uv32bit, param[1].v16bit, param[2].v16bit);
}

void STUB_glVertexAttrib2sARB( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glVertexAttrib2sARB( GLuint, GLshort, GLshort )
    maxParam = 3;
    READ_ENUM_PARAM(0);
    READ_PARAM(v16bit,1);
    READ_PARAM(v16bit,2);
    TR.skipLine();
    CHECK_USER_CALL(glVertexAttrib2sARB)
        UCT.glVertexAttrib2sARB(param[0].uv32bit, param[1].v16bit, param[2].v16bit);
    CHECK_GL_CALL(glVertexAttrib2sARB)
        JT.glVertexAttrib2sARB(param[0].uv32bit, param[1].v16bit, param[2].v16bit);
}

void STUB_glVertexAttrib2sNV( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glVertexAttrib2sNV( GLuint, GLshort, GLshort )
    maxParam = 3;
    READ_ENUM_PARAM(0);
    READ_PARAM(v16bit,1);
    READ_PARAM(v16bit,2);
    TR.skipLine();
    CHECK_USER_CALL(glVertexAttrib2sNV)
        UCT.glVertexAttrib2sNV(param[0].uv32bit, param[1].v16bit, param[2].v16bit);
    CHECK_GL_CALL(glVertexAttrib2sNV)
        JT.glVertexAttrib2sNV(param[0].uv32bit, param[1].v16bit, param[2].v16bit);
}

void STUB_glVertexAttrib2sv( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glVertexAttrib2sv( GLuint, const GLshort * )
    maxParam = 2;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ARRAY_PARAM( 1, buffer0, TraceReader::TEXT_SHORT);
    TR.skipLine();
    CHECK_USER_CALL(glVertexAttrib2sv)
        UCT.glVertexAttrib2sv(param[0].uv32bit, (const GLshort *)param[1].ptr);
    CHECK_GL_CALL(glVertexAttrib2sv)
        JT.glVertexAttrib2sv(param[0].uv32bit, (const GLshort *)param[1].ptr);
}

void STUB_glVertexAttrib2svARB( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glVertexAttrib2svARB( GLuint, const GLshort * )
    maxParam = 2;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ARRAY_PARAM( 1, buffer0, TraceReader::TEXT_SHORT);
    TR.skipLine();
    CHECK_USER_CALL(glVertexAttrib2svARB)
        UCT.glVertexAttrib2svARB(param[0].uv32bit, (const GLshort *)param[1].ptr);
    CHECK_GL_CALL(glVertexAttrib2svARB)
        JT.glVertexAttrib2svARB(param[0].uv32bit, (const GLshort *)param[1].ptr);
}

void STUB_glVertexAttrib2svNV( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glVertexAttrib2svNV( GLuint, const GLshort * )
    maxParam = 2;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ARRAY_PARAM( 1, buffer0, TraceReader::TEXT_SHORT);
    TR.skipLine();
    CHECK_USER_CALL(glVertexAttrib2svNV)
        UCT.glVertexAttrib2svNV(param[0].uv32bit, (const GLshort *)param[1].ptr);
    CHECK_GL_CALL(glVertexAttrib2svNV)
        JT.glVertexAttrib2svNV(param[0].uv32bit, (const GLshort *)param[1].ptr);
}

void STUB_glVertexAttrib3d( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glVertexAttrib3d( GLuint, GLdouble, GLdouble, GLdouble )
    maxParam = 4;
    READ_ENUM_PARAM(0);
    READ_DOUBLE_PARAM(1);
    READ_DOUBLE_PARAM(2);
    READ_DOUBLE_PARAM(3);
    TR.skipLine();
    CHECK_USER_CALL(glVertexAttrib3d)
        UCT.glVertexAttrib3d(param[0].uv32bit, param[1].fv64bit, param[2].fv64bit, param[3].fv64bit);
    CHECK_GL_CALL(glVertexAttrib3d)
        JT.glVertexAttrib3d(param[0].uv32bit, param[1].fv64bit, param[2].fv64bit, param[3].fv64bit);
}

void STUB_glVertexAttrib3dARB( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glVertexAttrib3dARB( GLuint, GLdouble, GLdouble, GLdouble )
    maxParam = 4;
    READ_ENUM_PARAM(0);
    READ_DOUBLE_PARAM(1);
    READ_DOUBLE_PARAM(2);
    READ_DOUBLE_PARAM(3);
    TR.skipLine();
    CHECK_USER_CALL(glVertexAttrib3dARB)
        UCT.glVertexAttrib3dARB(param[0].uv32bit, param[1].fv64bit, param[2].fv64bit, param[3].fv64bit);
    CHECK_GL_CALL(glVertexAttrib3dARB)
        JT.glVertexAttrib3dARB(param[0].uv32bit, param[1].fv64bit, param[2].fv64bit, param[3].fv64bit);
}

void STUB_glVertexAttrib3dNV( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glVertexAttrib3dNV( GLuint, GLdouble, GLdouble, GLdouble )
    maxParam = 4;
    READ_ENUM_PARAM(0);
    READ_DOUBLE_PARAM(1);
    READ_DOUBLE_PARAM(2);
    READ_DOUBLE_PARAM(3);
    TR.skipLine();
    CHECK_USER_CALL(glVertexAttrib3dNV)
        UCT.glVertexAttrib3dNV(param[0].uv32bit, param[1].fv64bit, param[2].fv64bit, param[3].fv64bit);
    CHECK_GL_CALL(glVertexAttrib3dNV)
        JT.glVertexAttrib3dNV(param[0].uv32bit, param[1].fv64bit, param[2].fv64bit, param[3].fv64bit);
}

void STUB_glVertexAttrib3dv( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glVertexAttrib3dv( GLuint, const GLdouble * )
    maxParam = 2;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ARRAY_PARAM( 1, buffer0, TraceReader::TEXT_DOUBLE);
    TR.skipLine();
    CHECK_USER_CALL(glVertexAttrib3dv)
        UCT.glVertexAttrib3dv(param[0].uv32bit, (const GLdouble *)param[1].ptr);
    CHECK_GL_CALL(glVertexAttrib3dv)
        JT.glVertexAttrib3dv(param[0].uv32bit, (const GLdouble *)param[1].ptr);
}

void STUB_glVertexAttrib3dvARB( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glVertexAttrib3dvARB( GLuint, const GLdouble * )
    maxParam = 2;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ARRAY_PARAM( 1, buffer0, TraceReader::TEXT_DOUBLE);
    TR.skipLine();
    CHECK_USER_CALL(glVertexAttrib3dvARB)
        UCT.glVertexAttrib3dvARB(param[0].uv32bit, (const GLdouble *)param[1].ptr);
    CHECK_GL_CALL(glVertexAttrib3dvARB)
        JT.glVertexAttrib3dvARB(param[0].uv32bit, (const GLdouble *)param[1].ptr);
}

void STUB_glVertexAttrib3dvNV( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glVertexAttrib3dvNV( GLuint, const GLdouble * )
    maxParam = 2;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ARRAY_PARAM( 1, buffer0, TraceReader::TEXT_DOUBLE);
    TR.skipLine();
    CHECK_USER_CALL(glVertexAttrib3dvNV)
        UCT.glVertexAttrib3dvNV(param[0].uv32bit, (const GLdouble *)param[1].ptr);
    CHECK_GL_CALL(glVertexAttrib3dvNV)
        JT.glVertexAttrib3dvNV(param[0].uv32bit, (const GLdouble *)param[1].ptr);
}

void STUB_glVertexAttrib3f( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glVertexAttrib3f( GLuint, GLfloat, GLfloat, GLfloat )
    maxParam = 4;
    READ_ENUM_PARAM(0);
    READ_PARAM(fv32bit,1);
    READ_PARAM(fv32bit,2);
    READ_PARAM(fv32bit,3);
    TR.skipLine();
    CHECK_USER_CALL(glVertexAttrib3f)
        UCT.glVertexAttrib3f(param[0].uv32bit, param[1].fv32bit, param[2].fv32bit, param[3].fv32bit);
    CHECK_GL_CALL(glVertexAttrib3f)
        JT.glVertexAttrib3f(param[0].uv32bit, param[1].fv32bit, param[2].fv32bit, param[3].fv32bit);
}

void STUB_glVertexAttrib3fARB( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glVertexAttrib3fARB( GLuint, GLfloat, GLfloat, GLfloat )
    maxParam = 4;
    READ_ENUM_PARAM(0);
    READ_PARAM(fv32bit,1);
    READ_PARAM(fv32bit,2);
    READ_PARAM(fv32bit,3);
    TR.skipLine();
    CHECK_USER_CALL(glVertexAttrib3fARB)
        UCT.glVertexAttrib3fARB(param[0].uv32bit, param[1].fv32bit, param[2].fv32bit, param[3].fv32bit);
    CHECK_GL_CALL(glVertexAttrib3fARB)
        JT.glVertexAttrib3fARB(param[0].uv32bit, param[1].fv32bit, param[2].fv32bit, param[3].fv32bit);
}

void STUB_glVertexAttrib3fNV( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glVertexAttrib3fNV( GLuint, GLfloat, GLfloat, GLfloat )
    maxParam = 4;
    READ_ENUM_PARAM(0);
    READ_PARAM(fv32bit,1);
    READ_PARAM(fv32bit,2);
    READ_PARAM(fv32bit,3);
    TR.skipLine();
    CHECK_USER_CALL(glVertexAttrib3fNV)
        UCT.glVertexAttrib3fNV(param[0].uv32bit, param[1].fv32bit, param[2].fv32bit, param[3].fv32bit);
    CHECK_GL_CALL(glVertexAttrib3fNV)
        JT.glVertexAttrib3fNV(param[0].uv32bit, param[1].fv32bit, param[2].fv32bit, param[3].fv32bit);
}

void STUB_glVertexAttrib3fv( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glVertexAttrib3fv( GLuint, const GLfloat * )
    maxParam = 2;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ARRAY_PARAM( 1, buffer0, TraceReader::TEXT_FLOAT);
    TR.skipLine();
    CHECK_USER_CALL(glVertexAttrib3fv)
        UCT.glVertexAttrib3fv(param[0].uv32bit, (const GLfloat *)param[1].ptr);
    CHECK_GL_CALL(glVertexAttrib3fv)
        JT.glVertexAttrib3fv(param[0].uv32bit, (const GLfloat *)param[1].ptr);
}

void STUB_glVertexAttrib3fvARB( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glVertexAttrib3fvARB( GLuint, const GLfloat * )
    maxParam = 2;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ARRAY_PARAM( 1, buffer0, TraceReader::TEXT_FLOAT);
    TR.skipLine();
    CHECK_USER_CALL(glVertexAttrib3fvARB)
        UCT.glVertexAttrib3fvARB(param[0].uv32bit, (const GLfloat *)param[1].ptr);
    CHECK_GL_CALL(glVertexAttrib3fvARB)
        JT.glVertexAttrib3fvARB(param[0].uv32bit, (const GLfloat *)param[1].ptr);
}

void STUB_glVertexAttrib3fvNV( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glVertexAttrib3fvNV( GLuint, const GLfloat * )
    maxParam = 2;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ARRAY_PARAM( 1, buffer0, TraceReader::TEXT_FLOAT);
    TR.skipLine();
    CHECK_USER_CALL(glVertexAttrib3fvNV)
        UCT.glVertexAttrib3fvNV(param[0].uv32bit, (const GLfloat *)param[1].ptr);
    CHECK_GL_CALL(glVertexAttrib3fvNV)
        JT.glVertexAttrib3fvNV(param[0].uv32bit, (const GLfloat *)param[1].ptr);
}

void STUB_glVertexAttrib3hNV( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glVertexAttrib3hNV( GLuint, GLhalfNV, GLhalfNV, GLhalfNV )
    // Call not playable
    TR.skipCall();
}

void STUB_glVertexAttrib3hvNV( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glVertexAttrib3hvNV( GLuint, const GLhalfNV * )
    // Call not playable
    TR.skipCall();
}

void STUB_glVertexAttrib3s( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glVertexAttrib3s( GLuint, GLshort, GLshort, GLshort )
    maxParam = 4;
    READ_ENUM_PARAM(0);
    READ_PARAM(v16bit,1);
    READ_PARAM(v16bit,2);
    READ_PARAM(v16bit,3);
    TR.skipLine();
    CHECK_USER_CALL(glVertexAttrib3s)
        UCT.glVertexAttrib3s(param[0].uv32bit, param[1].v16bit, param[2].v16bit, param[3].v16bit);
    CHECK_GL_CALL(glVertexAttrib3s)
        JT.glVertexAttrib3s(param[0].uv32bit, param[1].v16bit, param[2].v16bit, param[3].v16bit);
}

void STUB_glVertexAttrib3sARB( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glVertexAttrib3sARB( GLuint, GLshort, GLshort, GLshort )
    maxParam = 4;
    READ_ENUM_PARAM(0);
    READ_PARAM(v16bit,1);
    READ_PARAM(v16bit,2);
    READ_PARAM(v16bit,3);
    TR.skipLine();
    CHECK_USER_CALL(glVertexAttrib3sARB)
        UCT.glVertexAttrib3sARB(param[0].uv32bit, param[1].v16bit, param[2].v16bit, param[3].v16bit);
    CHECK_GL_CALL(glVertexAttrib3sARB)
        JT.glVertexAttrib3sARB(param[0].uv32bit, param[1].v16bit, param[2].v16bit, param[3].v16bit);
}

void STUB_glVertexAttrib3sNV( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glVertexAttrib3sNV( GLuint, GLshort, GLshort, GLshort )
    maxParam = 4;
    READ_ENUM_PARAM(0);
    READ_PARAM(v16bit,1);
    READ_PARAM(v16bit,2);
    READ_PARAM(v16bit,3);
    TR.skipLine();
    CHECK_USER_CALL(glVertexAttrib3sNV)
        UCT.glVertexAttrib3sNV(param[0].uv32bit, param[1].v16bit, param[2].v16bit, param[3].v16bit);
    CHECK_GL_CALL(glVertexAttrib3sNV)
        JT.glVertexAttrib3sNV(param[0].uv32bit, param[1].v16bit, param[2].v16bit, param[3].v16bit);
}

void STUB_glVertexAttrib3sv( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glVertexAttrib3sv( GLuint, const GLshort * )
    maxParam = 2;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ARRAY_PARAM( 1, buffer0, TraceReader::TEXT_SHORT);
    TR.skipLine();
    CHECK_USER_CALL(glVertexAttrib3sv)
        UCT.glVertexAttrib3sv(param[0].uv32bit, (const GLshort *)param[1].ptr);
    CHECK_GL_CALL(glVertexAttrib3sv)
        JT.glVertexAttrib3sv(param[0].uv32bit, (const GLshort *)param[1].ptr);
}

void STUB_glVertexAttrib3svARB( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glVertexAttrib3svARB( GLuint, const GLshort * )
    maxParam = 2;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ARRAY_PARAM( 1, buffer0, TraceReader::TEXT_SHORT);
    TR.skipLine();
    CHECK_USER_CALL(glVertexAttrib3svARB)
        UCT.glVertexAttrib3svARB(param[0].uv32bit, (const GLshort *)param[1].ptr);
    CHECK_GL_CALL(glVertexAttrib3svARB)
        JT.glVertexAttrib3svARB(param[0].uv32bit, (const GLshort *)param[1].ptr);
}

void STUB_glVertexAttrib3svNV( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glVertexAttrib3svNV( GLuint, const GLshort * )
    maxParam = 2;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ARRAY_PARAM( 1, buffer0, TraceReader::TEXT_SHORT);
    TR.skipLine();
    CHECK_USER_CALL(glVertexAttrib3svNV)
        UCT.glVertexAttrib3svNV(param[0].uv32bit, (const GLshort *)param[1].ptr);
    CHECK_GL_CALL(glVertexAttrib3svNV)
        JT.glVertexAttrib3svNV(param[0].uv32bit, (const GLshort *)param[1].ptr);
}

void STUB_glVertexAttrib4Nbv( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glVertexAttrib4Nbv( GLuint, const GLbyte * )
    maxParam = 2;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ARRAY_PARAM( 1, buffer0, TraceReader::TEXT_BYTE);
    TR.skipLine();
    CHECK_USER_CALL(glVertexAttrib4Nbv)
        UCT.glVertexAttrib4Nbv(param[0].uv32bit, (const GLbyte *)param[1].ptr);
    CHECK_GL_CALL(glVertexAttrib4Nbv)
        JT.glVertexAttrib4Nbv(param[0].uv32bit, (const GLbyte *)param[1].ptr);
}

void STUB_glVertexAttrib4NbvARB( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glVertexAttrib4NbvARB( GLuint, const GLbyte * )
    maxParam = 2;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ARRAY_PARAM( 1, buffer0, TraceReader::TEXT_BYTE);
    TR.skipLine();
    CHECK_USER_CALL(glVertexAttrib4NbvARB)
        UCT.glVertexAttrib4NbvARB(param[0].uv32bit, (const GLbyte *)param[1].ptr);
    CHECK_GL_CALL(glVertexAttrib4NbvARB)
        JT.glVertexAttrib4NbvARB(param[0].uv32bit, (const GLbyte *)param[1].ptr);
}

void STUB_glVertexAttrib4Niv( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glVertexAttrib4Niv( GLuint, const GLint * )
    maxParam = 2;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ARRAY_PARAM( 1, buffer0, TraceReader::TEXT_INT);
    TR.skipLine();
    CHECK_USER_CALL(glVertexAttrib4Niv)
        UCT.glVertexAttrib4Niv(param[0].uv32bit, (const GLint *)param[1].ptr);
    CHECK_GL_CALL(glVertexAttrib4Niv)
        JT.glVertexAttrib4Niv(param[0].uv32bit, (const GLint *)param[1].ptr);
}

void STUB_glVertexAttrib4NivARB( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glVertexAttrib4NivARB( GLuint, const GLint * )
    maxParam = 2;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ARRAY_PARAM( 1, buffer0, TraceReader::TEXT_INT);
    TR.skipLine();
    CHECK_USER_CALL(glVertexAttrib4NivARB)
        UCT.glVertexAttrib4NivARB(param[0].uv32bit, (const GLint *)param[1].ptr);
    CHECK_GL_CALL(glVertexAttrib4NivARB)
        JT.glVertexAttrib4NivARB(param[0].uv32bit, (const GLint *)param[1].ptr);
}

void STUB_glVertexAttrib4Nsv( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glVertexAttrib4Nsv( GLuint, const GLshort * )
    maxParam = 2;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ARRAY_PARAM( 1, buffer0, TraceReader::TEXT_SHORT);
    TR.skipLine();
    CHECK_USER_CALL(glVertexAttrib4Nsv)
        UCT.glVertexAttrib4Nsv(param[0].uv32bit, (const GLshort *)param[1].ptr);
    CHECK_GL_CALL(glVertexAttrib4Nsv)
        JT.glVertexAttrib4Nsv(param[0].uv32bit, (const GLshort *)param[1].ptr);
}

void STUB_glVertexAttrib4NsvARB( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glVertexAttrib4NsvARB( GLuint, const GLshort * )
    maxParam = 2;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ARRAY_PARAM( 1, buffer0, TraceReader::TEXT_SHORT);
    TR.skipLine();
    CHECK_USER_CALL(glVertexAttrib4NsvARB)
        UCT.glVertexAttrib4NsvARB(param[0].uv32bit, (const GLshort *)param[1].ptr);
    CHECK_GL_CALL(glVertexAttrib4NsvARB)
        JT.glVertexAttrib4NsvARB(param[0].uv32bit, (const GLshort *)param[1].ptr);
}

void STUB_glVertexAttrib4Nub( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glVertexAttrib4Nub( GLuint, GLubyte, GLubyte, GLubyte, GLubyte )
    maxParam = 5;
    READ_ENUM_PARAM(0);
    READ_PARAM(uv8bit,1);
    READ_PARAM(uv8bit,2);
    READ_PARAM(uv8bit,3);
    READ_PARAM(uv8bit,4);
    TR.skipLine();
    CHECK_USER_CALL(glVertexAttrib4Nub)
        UCT.glVertexAttrib4Nub(param[0].uv32bit, param[1].uv8bit, param[2].uv8bit, param[3].uv8bit, param[4].uv8bit);
    CHECK_GL_CALL(glVertexAttrib4Nub)
        JT.glVertexAttrib4Nub(param[0].uv32bit, param[1].uv8bit, param[2].uv8bit, param[3].uv8bit, param[4].uv8bit);
}

void STUB_glVertexAttrib4NubARB( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glVertexAttrib4NubARB( GLuint, GLubyte, GLubyte, GLubyte, GLubyte )
    maxParam = 5;
    READ_ENUM_PARAM(0);
    READ_PARAM(uv8bit,1);
    READ_PARAM(uv8bit,2);
    READ_PARAM(uv8bit,3);
    READ_PARAM(uv8bit,4);
    TR.skipLine();
    CHECK_USER_CALL(glVertexAttrib4NubARB)
        UCT.glVertexAttrib4NubARB(param[0].uv32bit, param[1].uv8bit, param[2].uv8bit, param[3].uv8bit, param[4].uv8bit);
    CHECK_GL_CALL(glVertexAttrib4NubARB)
        JT.glVertexAttrib4NubARB(param[0].uv32bit, param[1].uv8bit, param[2].uv8bit, param[3].uv8bit, param[4].uv8bit);
}

void STUB_glVertexAttrib4Nubv( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glVertexAttrib4Nubv( GLuint, const GLubyte * )
    maxParam = 2;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ARRAY_PARAM( 1, buffer0, TraceReader::TEXT_BYTE);
    TR.skipLine();
    CHECK_USER_CALL(glVertexAttrib4Nubv)
        UCT.glVertexAttrib4Nubv(param[0].uv32bit, (const GLubyte *)param[1].ptr);
    CHECK_GL_CALL(glVertexAttrib4Nubv)
        JT.glVertexAttrib4Nubv(param[0].uv32bit, (const GLubyte *)param[1].ptr);
}

void STUB_glVertexAttrib4NubvARB( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glVertexAttrib4NubvARB( GLuint, const GLubyte * )
    maxParam = 2;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ARRAY_PARAM( 1, buffer0, TraceReader::TEXT_BYTE);
    TR.skipLine();
    CHECK_USER_CALL(glVertexAttrib4NubvARB)
        UCT.glVertexAttrib4NubvARB(param[0].uv32bit, (const GLubyte *)param[1].ptr);
    CHECK_GL_CALL(glVertexAttrib4NubvARB)
        JT.glVertexAttrib4NubvARB(param[0].uv32bit, (const GLubyte *)param[1].ptr);
}

void STUB_glVertexAttrib4Nuiv( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glVertexAttrib4Nuiv( GLuint, const GLuint * )
    maxParam = 2;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ARRAY_PARAM( 1, buffer0, TraceReader::TEXT_INT);
    TR.skipLine();
    CHECK_USER_CALL(glVertexAttrib4Nuiv)
        UCT.glVertexAttrib4Nuiv(param[0].uv32bit, (const GLuint *)param[1].ptr);
    CHECK_GL_CALL(glVertexAttrib4Nuiv)
        JT.glVertexAttrib4Nuiv(param[0].uv32bit, (const GLuint *)param[1].ptr);
}

void STUB_glVertexAttrib4NuivARB( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glVertexAttrib4NuivARB( GLuint, const GLuint * )
    maxParam = 2;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ARRAY_PARAM( 1, buffer0, TraceReader::TEXT_INT);
    TR.skipLine();
    CHECK_USER_CALL(glVertexAttrib4NuivARB)
        UCT.glVertexAttrib4NuivARB(param[0].uv32bit, (const GLuint *)param[1].ptr);
    CHECK_GL_CALL(glVertexAttrib4NuivARB)
        JT.glVertexAttrib4NuivARB(param[0].uv32bit, (const GLuint *)param[1].ptr);
}

void STUB_glVertexAttrib4Nusv( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glVertexAttrib4Nusv( GLuint, const GLushort * )
    maxParam = 2;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ARRAY_PARAM( 1, buffer0, TraceReader::TEXT_SHORT);
    TR.skipLine();
    CHECK_USER_CALL(glVertexAttrib4Nusv)
        UCT.glVertexAttrib4Nusv(param[0].uv32bit, (const GLushort *)param[1].ptr);
    CHECK_GL_CALL(glVertexAttrib4Nusv)
        JT.glVertexAttrib4Nusv(param[0].uv32bit, (const GLushort *)param[1].ptr);
}

void STUB_glVertexAttrib4NusvARB( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glVertexAttrib4NusvARB( GLuint, const GLushort * )
    maxParam = 2;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ARRAY_PARAM( 1, buffer0, TraceReader::TEXT_SHORT);
    TR.skipLine();
    CHECK_USER_CALL(glVertexAttrib4NusvARB)
        UCT.glVertexAttrib4NusvARB(param[0].uv32bit, (const GLushort *)param[1].ptr);
    CHECK_GL_CALL(glVertexAttrib4NusvARB)
        JT.glVertexAttrib4NusvARB(param[0].uv32bit, (const GLushort *)param[1].ptr);
}

void STUB_glVertexAttrib4bv( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glVertexAttrib4bv( GLuint, const GLbyte * )
    maxParam = 2;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ARRAY_PARAM( 1, buffer0, TraceReader::TEXT_BYTE);
    TR.skipLine();
    CHECK_USER_CALL(glVertexAttrib4bv)
        UCT.glVertexAttrib4bv(param[0].uv32bit, (const GLbyte *)param[1].ptr);
    CHECK_GL_CALL(glVertexAttrib4bv)
        JT.glVertexAttrib4bv(param[0].uv32bit, (const GLbyte *)param[1].ptr);
}

void STUB_glVertexAttrib4bvARB( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glVertexAttrib4bvARB( GLuint, const GLbyte * )
    maxParam = 2;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ARRAY_PARAM( 1, buffer0, TraceReader::TEXT_BYTE);
    TR.skipLine();
    CHECK_USER_CALL(glVertexAttrib4bvARB)
        UCT.glVertexAttrib4bvARB(param[0].uv32bit, (const GLbyte *)param[1].ptr);
    CHECK_GL_CALL(glVertexAttrib4bvARB)
        JT.glVertexAttrib4bvARB(param[0].uv32bit, (const GLbyte *)param[1].ptr);
}

void STUB_glVertexAttrib4d( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glVertexAttrib4d( GLuint, GLdouble, GLdouble, GLdouble, GLdouble )
    maxParam = 5;
    READ_ENUM_PARAM(0);
    READ_DOUBLE_PARAM(1);
    READ_DOUBLE_PARAM(2);
    READ_DOUBLE_PARAM(3);
    READ_DOUBLE_PARAM(4);
    TR.skipLine();
    CHECK_USER_CALL(glVertexAttrib4d)
        UCT.glVertexAttrib4d(param[0].uv32bit, param[1].fv64bit, param[2].fv64bit, param[3].fv64bit, param[4].fv64bit);
    CHECK_GL_CALL(glVertexAttrib4d)
        JT.glVertexAttrib4d(param[0].uv32bit, param[1].fv64bit, param[2].fv64bit, param[3].fv64bit, param[4].fv64bit);
}

void STUB_glVertexAttrib4dARB( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glVertexAttrib4dARB( GLuint, GLdouble, GLdouble, GLdouble, GLdouble )
    maxParam = 5;
    READ_ENUM_PARAM(0);
    READ_DOUBLE_PARAM(1);
    READ_DOUBLE_PARAM(2);
    READ_DOUBLE_PARAM(3);
    READ_DOUBLE_PARAM(4);
    TR.skipLine();
    CHECK_USER_CALL(glVertexAttrib4dARB)
        UCT.glVertexAttrib4dARB(param[0].uv32bit, param[1].fv64bit, param[2].fv64bit, param[3].fv64bit, param[4].fv64bit);
    CHECK_GL_CALL(glVertexAttrib4dARB)
        JT.glVertexAttrib4dARB(param[0].uv32bit, param[1].fv64bit, param[2].fv64bit, param[3].fv64bit, param[4].fv64bit);
}

void STUB_glVertexAttrib4dNV( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glVertexAttrib4dNV( GLuint, GLdouble, GLdouble, GLdouble, GLdouble )
    maxParam = 5;
    READ_ENUM_PARAM(0);
    READ_DOUBLE_PARAM(1);
    READ_DOUBLE_PARAM(2);
    READ_DOUBLE_PARAM(3);
    READ_DOUBLE_PARAM(4);
    TR.skipLine();
    CHECK_USER_CALL(glVertexAttrib4dNV)
        UCT.glVertexAttrib4dNV(param[0].uv32bit, param[1].fv64bit, param[2].fv64bit, param[3].fv64bit, param[4].fv64bit);
    CHECK_GL_CALL(glVertexAttrib4dNV)
        JT.glVertexAttrib4dNV(param[0].uv32bit, param[1].fv64bit, param[2].fv64bit, param[3].fv64bit, param[4].fv64bit);
}

void STUB_glVertexAttrib4dv( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glVertexAttrib4dv( GLuint, const GLdouble * )
    maxParam = 2;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ARRAY_PARAM( 1, buffer0, TraceReader::TEXT_DOUBLE);
    TR.skipLine();
    CHECK_USER_CALL(glVertexAttrib4dv)
        UCT.glVertexAttrib4dv(param[0].uv32bit, (const GLdouble *)param[1].ptr);
    CHECK_GL_CALL(glVertexAttrib4dv)
        JT.glVertexAttrib4dv(param[0].uv32bit, (const GLdouble *)param[1].ptr);
}

void STUB_glVertexAttrib4dvARB( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glVertexAttrib4dvARB( GLuint, const GLdouble * )
    maxParam = 2;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ARRAY_PARAM( 1, buffer0, TraceReader::TEXT_DOUBLE);
    TR.skipLine();
    CHECK_USER_CALL(glVertexAttrib4dvARB)
        UCT.glVertexAttrib4dvARB(param[0].uv32bit, (const GLdouble *)param[1].ptr);
    CHECK_GL_CALL(glVertexAttrib4dvARB)
        JT.glVertexAttrib4dvARB(param[0].uv32bit, (const GLdouble *)param[1].ptr);
}

void STUB_glVertexAttrib4dvNV( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glVertexAttrib4dvNV( GLuint, const GLdouble * )
    maxParam = 2;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ARRAY_PARAM( 1, buffer0, TraceReader::TEXT_DOUBLE);
    TR.skipLine();
    CHECK_USER_CALL(glVertexAttrib4dvNV)
        UCT.glVertexAttrib4dvNV(param[0].uv32bit, (const GLdouble *)param[1].ptr);
    CHECK_GL_CALL(glVertexAttrib4dvNV)
        JT.glVertexAttrib4dvNV(param[0].uv32bit, (const GLdouble *)param[1].ptr);
}

void STUB_glVertexAttrib4f( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glVertexAttrib4f( GLuint, GLfloat, GLfloat, GLfloat, GLfloat )
    maxParam = 5;
    READ_ENUM_PARAM(0);
    READ_PARAM(fv32bit,1);
    READ_PARAM(fv32bit,2);
    READ_PARAM(fv32bit,3);
    READ_PARAM(fv32bit,4);
    TR.skipLine();
    CHECK_USER_CALL(glVertexAttrib4f)
        UCT.glVertexAttrib4f(param[0].uv32bit, param[1].fv32bit, param[2].fv32bit, param[3].fv32bit, param[4].fv32bit);
    CHECK_GL_CALL(glVertexAttrib4f)
        JT.glVertexAttrib4f(param[0].uv32bit, param[1].fv32bit, param[2].fv32bit, param[3].fv32bit, param[4].fv32bit);
}

void STUB_glVertexAttrib4fARB( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glVertexAttrib4fARB( GLuint, GLfloat, GLfloat, GLfloat, GLfloat )
    maxParam = 5;
    READ_ENUM_PARAM(0);
    READ_PARAM(fv32bit,1);
    READ_PARAM(fv32bit,2);
    READ_PARAM(fv32bit,3);
    READ_PARAM(fv32bit,4);
    TR.skipLine();
    CHECK_USER_CALL(glVertexAttrib4fARB)
        UCT.glVertexAttrib4fARB(param[0].uv32bit, param[1].fv32bit, param[2].fv32bit, param[3].fv32bit, param[4].fv32bit);
    CHECK_GL_CALL(glVertexAttrib4fARB)
        JT.glVertexAttrib4fARB(param[0].uv32bit, param[1].fv32bit, param[2].fv32bit, param[3].fv32bit, param[4].fv32bit);
}

void STUB_glVertexAttrib4fNV( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glVertexAttrib4fNV( GLuint, GLfloat, GLfloat, GLfloat, GLfloat )
    maxParam = 5;
    READ_ENUM_PARAM(0);
    READ_PARAM(fv32bit,1);
    READ_PARAM(fv32bit,2);
    READ_PARAM(fv32bit,3);
    READ_PARAM(fv32bit,4);
    TR.skipLine();
    CHECK_USER_CALL(glVertexAttrib4fNV)
        UCT.glVertexAttrib4fNV(param[0].uv32bit, param[1].fv32bit, param[2].fv32bit, param[3].fv32bit, param[4].fv32bit);
    CHECK_GL_CALL(glVertexAttrib4fNV)
        JT.glVertexAttrib4fNV(param[0].uv32bit, param[1].fv32bit, param[2].fv32bit, param[3].fv32bit, param[4].fv32bit);
}

void STUB_glVertexAttrib4fv( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glVertexAttrib4fv( GLuint, const GLfloat * )
    maxParam = 2;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ARRAY_PARAM( 1, buffer0, TraceReader::TEXT_FLOAT);
    TR.skipLine();
    CHECK_USER_CALL(glVertexAttrib4fv)
        UCT.glVertexAttrib4fv(param[0].uv32bit, (const GLfloat *)param[1].ptr);
    CHECK_GL_CALL(glVertexAttrib4fv)
        JT.glVertexAttrib4fv(param[0].uv32bit, (const GLfloat *)param[1].ptr);
}

void STUB_glVertexAttrib4fvARB( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glVertexAttrib4fvARB( GLuint, const GLfloat * )
    maxParam = 2;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ARRAY_PARAM( 1, buffer0, TraceReader::TEXT_FLOAT);
    TR.skipLine();
    CHECK_USER_CALL(glVertexAttrib4fvARB)
        UCT.glVertexAttrib4fvARB(param[0].uv32bit, (const GLfloat *)param[1].ptr);
    CHECK_GL_CALL(glVertexAttrib4fvARB)
        JT.glVertexAttrib4fvARB(param[0].uv32bit, (const GLfloat *)param[1].ptr);
}

void STUB_glVertexAttrib4fvNV( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glVertexAttrib4fvNV( GLuint, const GLfloat * )
    maxParam = 2;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ARRAY_PARAM( 1, buffer0, TraceReader::TEXT_FLOAT);
    TR.skipLine();
    CHECK_USER_CALL(glVertexAttrib4fvNV)
        UCT.glVertexAttrib4fvNV(param[0].uv32bit, (const GLfloat *)param[1].ptr);
    CHECK_GL_CALL(glVertexAttrib4fvNV)
        JT.glVertexAttrib4fvNV(param[0].uv32bit, (const GLfloat *)param[1].ptr);
}

void STUB_glVertexAttrib4hNV( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glVertexAttrib4hNV( GLuint, GLhalfNV, GLhalfNV, GLhalfNV, GLhalfNV )
    // Call not playable
    TR.skipCall();
}

void STUB_glVertexAttrib4hvNV( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glVertexAttrib4hvNV( GLuint, const GLhalfNV * )
    // Call not playable
    TR.skipCall();
}

void STUB_glVertexAttrib4iv( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glVertexAttrib4iv( GLuint, const GLint * )
    maxParam = 2;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ARRAY_PARAM( 1, buffer0, TraceReader::TEXT_INT);
    TR.skipLine();
    CHECK_USER_CALL(glVertexAttrib4iv)
        UCT.glVertexAttrib4iv(param[0].uv32bit, (const GLint *)param[1].ptr);
    CHECK_GL_CALL(glVertexAttrib4iv)
        JT.glVertexAttrib4iv(param[0].uv32bit, (const GLint *)param[1].ptr);
}

void STUB_glVertexAttrib4ivARB( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glVertexAttrib4ivARB( GLuint, const GLint * )
    maxParam = 2;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ARRAY_PARAM( 1, buffer0, TraceReader::TEXT_INT);
    TR.skipLine();
    CHECK_USER_CALL(glVertexAttrib4ivARB)
        UCT.glVertexAttrib4ivARB(param[0].uv32bit, (const GLint *)param[1].ptr);
    CHECK_GL_CALL(glVertexAttrib4ivARB)
        JT.glVertexAttrib4ivARB(param[0].uv32bit, (const GLint *)param[1].ptr);
}

void STUB_glVertexAttrib4s( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glVertexAttrib4s( GLuint, GLshort, GLshort, GLshort, GLshort )
    maxParam = 5;
    READ_ENUM_PARAM(0);
    READ_PARAM(v16bit,1);
    READ_PARAM(v16bit,2);
    READ_PARAM(v16bit,3);
    READ_PARAM(v16bit,4);
    TR.skipLine();
    CHECK_USER_CALL(glVertexAttrib4s)
        UCT.glVertexAttrib4s(param[0].uv32bit, param[1].v16bit, param[2].v16bit, param[3].v16bit, param[4].v16bit);
    CHECK_GL_CALL(glVertexAttrib4s)
        JT.glVertexAttrib4s(param[0].uv32bit, param[1].v16bit, param[2].v16bit, param[3].v16bit, param[4].v16bit);
}

void STUB_glVertexAttrib4sARB( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glVertexAttrib4sARB( GLuint, GLshort, GLshort, GLshort, GLshort )
    maxParam = 5;
    READ_ENUM_PARAM(0);
    READ_PARAM(v16bit,1);
    READ_PARAM(v16bit,2);
    READ_PARAM(v16bit,3);
    READ_PARAM(v16bit,4);
    TR.skipLine();
    CHECK_USER_CALL(glVertexAttrib4sARB)
        UCT.glVertexAttrib4sARB(param[0].uv32bit, param[1].v16bit, param[2].v16bit, param[3].v16bit, param[4].v16bit);
    CHECK_GL_CALL(glVertexAttrib4sARB)
        JT.glVertexAttrib4sARB(param[0].uv32bit, param[1].v16bit, param[2].v16bit, param[3].v16bit, param[4].v16bit);
}

void STUB_glVertexAttrib4sNV( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glVertexAttrib4sNV( GLuint, GLshort, GLshort, GLshort, GLshort )
    maxParam = 5;
    READ_ENUM_PARAM(0);
    READ_PARAM(v16bit,1);
    READ_PARAM(v16bit,2);
    READ_PARAM(v16bit,3);
    READ_PARAM(v16bit,4);
    TR.skipLine();
    CHECK_USER_CALL(glVertexAttrib4sNV)
        UCT.glVertexAttrib4sNV(param[0].uv32bit, param[1].v16bit, param[2].v16bit, param[3].v16bit, param[4].v16bit);
    CHECK_GL_CALL(glVertexAttrib4sNV)
        JT.glVertexAttrib4sNV(param[0].uv32bit, param[1].v16bit, param[2].v16bit, param[3].v16bit, param[4].v16bit);
}

void STUB_glVertexAttrib4sv( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glVertexAttrib4sv( GLuint, const GLshort * )
    maxParam = 2;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ARRAY_PARAM( 1, buffer0, TraceReader::TEXT_SHORT);
    TR.skipLine();
    CHECK_USER_CALL(glVertexAttrib4sv)
        UCT.glVertexAttrib4sv(param[0].uv32bit, (const GLshort *)param[1].ptr);
    CHECK_GL_CALL(glVertexAttrib4sv)
        JT.glVertexAttrib4sv(param[0].uv32bit, (const GLshort *)param[1].ptr);
}

void STUB_glVertexAttrib4svARB( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glVertexAttrib4svARB( GLuint, const GLshort * )
    maxParam = 2;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ARRAY_PARAM( 1, buffer0, TraceReader::TEXT_SHORT);
    TR.skipLine();
    CHECK_USER_CALL(glVertexAttrib4svARB)
        UCT.glVertexAttrib4svARB(param[0].uv32bit, (const GLshort *)param[1].ptr);
    CHECK_GL_CALL(glVertexAttrib4svARB)
        JT.glVertexAttrib4svARB(param[0].uv32bit, (const GLshort *)param[1].ptr);
}

void STUB_glVertexAttrib4svNV( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glVertexAttrib4svNV( GLuint, const GLshort * )
    maxParam = 2;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ARRAY_PARAM( 1, buffer0, TraceReader::TEXT_SHORT);
    TR.skipLine();
    CHECK_USER_CALL(glVertexAttrib4svNV)
        UCT.glVertexAttrib4svNV(param[0].uv32bit, (const GLshort *)param[1].ptr);
    CHECK_GL_CALL(glVertexAttrib4svNV)
        JT.glVertexAttrib4svNV(param[0].uv32bit, (const GLshort *)param[1].ptr);
}

void STUB_glVertexAttrib4ubNV( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glVertexAttrib4ubNV( GLuint, GLubyte, GLubyte, GLubyte, GLubyte )
    maxParam = 5;
    READ_ENUM_PARAM(0);
    READ_PARAM(uv8bit,1);
    READ_PARAM(uv8bit,2);
    READ_PARAM(uv8bit,3);
    READ_PARAM(uv8bit,4);
    TR.skipLine();
    CHECK_USER_CALL(glVertexAttrib4ubNV)
        UCT.glVertexAttrib4ubNV(param[0].uv32bit, param[1].uv8bit, param[2].uv8bit, param[3].uv8bit, param[4].uv8bit);
    CHECK_GL_CALL(glVertexAttrib4ubNV)
        JT.glVertexAttrib4ubNV(param[0].uv32bit, param[1].uv8bit, param[2].uv8bit, param[3].uv8bit, param[4].uv8bit);
}

void STUB_glVertexAttrib4ubv( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glVertexAttrib4ubv( GLuint, const GLubyte * )
    maxParam = 2;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ARRAY_PARAM( 1, buffer0, TraceReader::TEXT_BYTE);
    TR.skipLine();
    CHECK_USER_CALL(glVertexAttrib4ubv)
        UCT.glVertexAttrib4ubv(param[0].uv32bit, (const GLubyte *)param[1].ptr);
    CHECK_GL_CALL(glVertexAttrib4ubv)
        JT.glVertexAttrib4ubv(param[0].uv32bit, (const GLubyte *)param[1].ptr);
}

void STUB_glVertexAttrib4ubvARB( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glVertexAttrib4ubvARB( GLuint, const GLubyte * )
    maxParam = 2;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ARRAY_PARAM( 1, buffer0, TraceReader::TEXT_BYTE);
    TR.skipLine();
    CHECK_USER_CALL(glVertexAttrib4ubvARB)
        UCT.glVertexAttrib4ubvARB(param[0].uv32bit, (const GLubyte *)param[1].ptr);
    CHECK_GL_CALL(glVertexAttrib4ubvARB)
        JT.glVertexAttrib4ubvARB(param[0].uv32bit, (const GLubyte *)param[1].ptr);
}

void STUB_glVertexAttrib4ubvNV( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glVertexAttrib4ubvNV( GLuint, const GLubyte * )
    maxParam = 2;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ARRAY_PARAM( 1, buffer0, TraceReader::TEXT_BYTE);
    TR.skipLine();
    CHECK_USER_CALL(glVertexAttrib4ubvNV)
        UCT.glVertexAttrib4ubvNV(param[0].uv32bit, (const GLubyte *)param[1].ptr);
    CHECK_GL_CALL(glVertexAttrib4ubvNV)
        JT.glVertexAttrib4ubvNV(param[0].uv32bit, (const GLubyte *)param[1].ptr);
}

void STUB_glVertexAttrib4uiv( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glVertexAttrib4uiv( GLuint, const GLuint * )
    maxParam = 2;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ARRAY_PARAM( 1, buffer0, TraceReader::TEXT_INT);
    TR.skipLine();
    CHECK_USER_CALL(glVertexAttrib4uiv)
        UCT.glVertexAttrib4uiv(param[0].uv32bit, (const GLuint *)param[1].ptr);
    CHECK_GL_CALL(glVertexAttrib4uiv)
        JT.glVertexAttrib4uiv(param[0].uv32bit, (const GLuint *)param[1].ptr);
}

void STUB_glVertexAttrib4uivARB( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glVertexAttrib4uivARB( GLuint, const GLuint * )
    maxParam = 2;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ARRAY_PARAM( 1, buffer0, TraceReader::TEXT_INT);
    TR.skipLine();
    CHECK_USER_CALL(glVertexAttrib4uivARB)
        UCT.glVertexAttrib4uivARB(param[0].uv32bit, (const GLuint *)param[1].ptr);
    CHECK_GL_CALL(glVertexAttrib4uivARB)
        JT.glVertexAttrib4uivARB(param[0].uv32bit, (const GLuint *)param[1].ptr);
}

void STUB_glVertexAttrib4usv( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glVertexAttrib4usv( GLuint, const GLushort * )
    maxParam = 2;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ARRAY_PARAM( 1, buffer0, TraceReader::TEXT_SHORT);
    TR.skipLine();
    CHECK_USER_CALL(glVertexAttrib4usv)
        UCT.glVertexAttrib4usv(param[0].uv32bit, (const GLushort *)param[1].ptr);
    CHECK_GL_CALL(glVertexAttrib4usv)
        JT.glVertexAttrib4usv(param[0].uv32bit, (const GLushort *)param[1].ptr);
}

void STUB_glVertexAttrib4usvARB( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glVertexAttrib4usvARB( GLuint, const GLushort * )
    maxParam = 2;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ARRAY_PARAM( 1, buffer0, TraceReader::TEXT_SHORT);
    TR.skipLine();
    CHECK_USER_CALL(glVertexAttrib4usvARB)
        UCT.glVertexAttrib4usvARB(param[0].uv32bit, (const GLushort *)param[1].ptr);
    CHECK_GL_CALL(glVertexAttrib4usvARB)
        JT.glVertexAttrib4usvARB(param[0].uv32bit, (const GLushort *)param[1].ptr);
}

void STUB_glVertexAttribArrayObjectATI( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glVertexAttribArrayObjectATI( GLuint, GLint, GLenum, GLboolean, GLsizei, GLuint, GLuint )
    maxParam = 7;
    READ_ENUM_PARAM(0);
    READ_PARAM(v32bit,1);
    READ_ENUM_PARAM(2);
    READ_BOOLEAN_PARAM(3);
    READ_PARAM(v32bit,4);
    READ_ENUM_PARAM(5);
    READ_ENUM_PARAM(6);
    TR.skipLine();
    CHECK_USER_CALL(glVertexAttribArrayObjectATI)
        UCT.glVertexAttribArrayObjectATI(param[0].uv32bit, param[1].v32bit, param[2].uv32bit, param[3].boolean, param[4].v32bit, param[5].uv32bit, param[6].uv32bit);
    CHECK_GL_CALL(glVertexAttribArrayObjectATI)
        JT.glVertexAttribArrayObjectATI(param[0].uv32bit, param[1].v32bit, param[2].uv32bit, param[3].boolean, param[4].v32bit, param[5].uv32bit, param[6].uv32bit);
}

void STUB_glVertexAttribDivisorARB( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glVertexAttribDivisorARB( GLuint, GLuint )
    maxParam = 2;
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    TR.skipLine();
    CHECK_USER_CALL(glVertexAttribDivisorARB)
        UCT.glVertexAttribDivisorARB(param[0].uv32bit, param[1].uv32bit);
    CHECK_GL_CALL(glVertexAttribDivisorARB)
        JT.glVertexAttribDivisorARB(param[0].uv32bit, param[1].uv32bit);
}

void STUB_glVertexAttribI1i( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glVertexAttribI1i( GLuint, GLint )
    maxParam = 2;
    READ_ENUM_PARAM(0);
    READ_PARAM(v32bit,1);
    TR.skipLine();
    CHECK_USER_CALL(glVertexAttribI1i)
        UCT.glVertexAttribI1i(param[0].uv32bit, param[1].v32bit);
    CHECK_GL_CALL(glVertexAttribI1i)
        JT.glVertexAttribI1i(param[0].uv32bit, param[1].v32bit);
}

void STUB_glVertexAttribI1iEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glVertexAttribI1iEXT( GLuint, GLint )
    maxParam = 2;
    READ_ENUM_PARAM(0);
    READ_PARAM(v32bit,1);
    TR.skipLine();
    CHECK_USER_CALL(glVertexAttribI1iEXT)
        UCT.glVertexAttribI1iEXT(param[0].uv32bit, param[1].v32bit);
    CHECK_GL_CALL(glVertexAttribI1iEXT)
        JT.glVertexAttribI1iEXT(param[0].uv32bit, param[1].v32bit);
}

void STUB_glVertexAttribI1iv( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glVertexAttribI1iv( GLuint, const GLint * )
    maxParam = 2;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ARRAY_PARAM( 1, buffer0, TraceReader::TEXT_INT);
    TR.skipLine();
    CHECK_USER_CALL(glVertexAttribI1iv)
        UCT.glVertexAttribI1iv(param[0].uv32bit, (const GLint *)param[1].ptr);
    CHECK_GL_CALL(glVertexAttribI1iv)
        JT.glVertexAttribI1iv(param[0].uv32bit, (const GLint *)param[1].ptr);
}

void STUB_glVertexAttribI1ivEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glVertexAttribI1ivEXT( GLuint, const GLint * )
    maxParam = 2;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ARRAY_PARAM( 1, buffer0, TraceReader::TEXT_INT);
    TR.skipLine();
    CHECK_USER_CALL(glVertexAttribI1ivEXT)
        UCT.glVertexAttribI1ivEXT(param[0].uv32bit, (const GLint *)param[1].ptr);
    CHECK_GL_CALL(glVertexAttribI1ivEXT)
        JT.glVertexAttribI1ivEXT(param[0].uv32bit, (const GLint *)param[1].ptr);
}

void STUB_glVertexAttribI1ui( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glVertexAttribI1ui( GLuint, GLuint )
    maxParam = 2;
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    TR.skipLine();
    CHECK_USER_CALL(glVertexAttribI1ui)
        UCT.glVertexAttribI1ui(param[0].uv32bit, param[1].uv32bit);
    CHECK_GL_CALL(glVertexAttribI1ui)
        JT.glVertexAttribI1ui(param[0].uv32bit, param[1].uv32bit);
}

void STUB_glVertexAttribI1uiEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glVertexAttribI1uiEXT( GLuint, GLuint )
    maxParam = 2;
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    TR.skipLine();
    CHECK_USER_CALL(glVertexAttribI1uiEXT)
        UCT.glVertexAttribI1uiEXT(param[0].uv32bit, param[1].uv32bit);
    CHECK_GL_CALL(glVertexAttribI1uiEXT)
        JT.glVertexAttribI1uiEXT(param[0].uv32bit, param[1].uv32bit);
}

void STUB_glVertexAttribI1uiv( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glVertexAttribI1uiv( GLuint, const GLuint * )
    maxParam = 2;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ARRAY_PARAM( 1, buffer0, TraceReader::TEXT_INT);
    TR.skipLine();
    CHECK_USER_CALL(glVertexAttribI1uiv)
        UCT.glVertexAttribI1uiv(param[0].uv32bit, (const GLuint *)param[1].ptr);
    CHECK_GL_CALL(glVertexAttribI1uiv)
        JT.glVertexAttribI1uiv(param[0].uv32bit, (const GLuint *)param[1].ptr);
}

void STUB_glVertexAttribI1uivEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glVertexAttribI1uivEXT( GLuint, const GLuint * )
    maxParam = 2;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ARRAY_PARAM( 1, buffer0, TraceReader::TEXT_INT);
    TR.skipLine();
    CHECK_USER_CALL(glVertexAttribI1uivEXT)
        UCT.glVertexAttribI1uivEXT(param[0].uv32bit, (const GLuint *)param[1].ptr);
    CHECK_GL_CALL(glVertexAttribI1uivEXT)
        JT.glVertexAttribI1uivEXT(param[0].uv32bit, (const GLuint *)param[1].ptr);
}

void STUB_glVertexAttribI2i( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glVertexAttribI2i( GLuint, GLint, GLint )
    maxParam = 3;
    READ_ENUM_PARAM(0);
    READ_PARAM(v32bit,1);
    READ_PARAM(v32bit,2);
    TR.skipLine();
    CHECK_USER_CALL(glVertexAttribI2i)
        UCT.glVertexAttribI2i(param[0].uv32bit, param[1].v32bit, param[2].v32bit);
    CHECK_GL_CALL(glVertexAttribI2i)
        JT.glVertexAttribI2i(param[0].uv32bit, param[1].v32bit, param[2].v32bit);
}

void STUB_glVertexAttribI2iEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glVertexAttribI2iEXT( GLuint, GLint, GLint )
    maxParam = 3;
    READ_ENUM_PARAM(0);
    READ_PARAM(v32bit,1);
    READ_PARAM(v32bit,2);
    TR.skipLine();
    CHECK_USER_CALL(glVertexAttribI2iEXT)
        UCT.glVertexAttribI2iEXT(param[0].uv32bit, param[1].v32bit, param[2].v32bit);
    CHECK_GL_CALL(glVertexAttribI2iEXT)
        JT.glVertexAttribI2iEXT(param[0].uv32bit, param[1].v32bit, param[2].v32bit);
}

void STUB_glVertexAttribI2iv( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glVertexAttribI2iv( GLuint, const GLint * )
    maxParam = 2;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ARRAY_PARAM( 1, buffer0, TraceReader::TEXT_INT);
    TR.skipLine();
    CHECK_USER_CALL(glVertexAttribI2iv)
        UCT.glVertexAttribI2iv(param[0].uv32bit, (const GLint *)param[1].ptr);
    CHECK_GL_CALL(glVertexAttribI2iv)
        JT.glVertexAttribI2iv(param[0].uv32bit, (const GLint *)param[1].ptr);
}

void STUB_glVertexAttribI2ivEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glVertexAttribI2ivEXT( GLuint, const GLint * )
    maxParam = 2;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ARRAY_PARAM( 1, buffer0, TraceReader::TEXT_INT);
    TR.skipLine();
    CHECK_USER_CALL(glVertexAttribI2ivEXT)
        UCT.glVertexAttribI2ivEXT(param[0].uv32bit, (const GLint *)param[1].ptr);
    CHECK_GL_CALL(glVertexAttribI2ivEXT)
        JT.glVertexAttribI2ivEXT(param[0].uv32bit, (const GLint *)param[1].ptr);
}

void STUB_glVertexAttribI2ui( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glVertexAttribI2ui( GLuint, GLuint, GLuint )
    maxParam = 3;
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_ENUM_PARAM(2);
    TR.skipLine();
    CHECK_USER_CALL(glVertexAttribI2ui)
        UCT.glVertexAttribI2ui(param[0].uv32bit, param[1].uv32bit, param[2].uv32bit);
    CHECK_GL_CALL(glVertexAttribI2ui)
        JT.glVertexAttribI2ui(param[0].uv32bit, param[1].uv32bit, param[2].uv32bit);
}

void STUB_glVertexAttribI2uiEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glVertexAttribI2uiEXT( GLuint, GLuint, GLuint )
    maxParam = 3;
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_ENUM_PARAM(2);
    TR.skipLine();
    CHECK_USER_CALL(glVertexAttribI2uiEXT)
        UCT.glVertexAttribI2uiEXT(param[0].uv32bit, param[1].uv32bit, param[2].uv32bit);
    CHECK_GL_CALL(glVertexAttribI2uiEXT)
        JT.glVertexAttribI2uiEXT(param[0].uv32bit, param[1].uv32bit, param[2].uv32bit);
}

void STUB_glVertexAttribI2uiv( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glVertexAttribI2uiv( GLuint, const GLuint * )
    maxParam = 2;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ARRAY_PARAM( 1, buffer0, TraceReader::TEXT_INT);
    TR.skipLine();
    CHECK_USER_CALL(glVertexAttribI2uiv)
        UCT.glVertexAttribI2uiv(param[0].uv32bit, (const GLuint *)param[1].ptr);
    CHECK_GL_CALL(glVertexAttribI2uiv)
        JT.glVertexAttribI2uiv(param[0].uv32bit, (const GLuint *)param[1].ptr);
}

void STUB_glVertexAttribI2uivEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glVertexAttribI2uivEXT( GLuint, const GLuint * )
    maxParam = 2;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ARRAY_PARAM( 1, buffer0, TraceReader::TEXT_INT);
    TR.skipLine();
    CHECK_USER_CALL(glVertexAttribI2uivEXT)
        UCT.glVertexAttribI2uivEXT(param[0].uv32bit, (const GLuint *)param[1].ptr);
    CHECK_GL_CALL(glVertexAttribI2uivEXT)
        JT.glVertexAttribI2uivEXT(param[0].uv32bit, (const GLuint *)param[1].ptr);
}

void STUB_glVertexAttribI3i( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glVertexAttribI3i( GLuint, GLint, GLint, GLint )
    maxParam = 4;
    READ_ENUM_PARAM(0);
    READ_PARAM(v32bit,1);
    READ_PARAM(v32bit,2);
    READ_PARAM(v32bit,3);
    TR.skipLine();
    CHECK_USER_CALL(glVertexAttribI3i)
        UCT.glVertexAttribI3i(param[0].uv32bit, param[1].v32bit, param[2].v32bit, param[3].v32bit);
    CHECK_GL_CALL(glVertexAttribI3i)
        JT.glVertexAttribI3i(param[0].uv32bit, param[1].v32bit, param[2].v32bit, param[3].v32bit);
}

void STUB_glVertexAttribI3iEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glVertexAttribI3iEXT( GLuint, GLint, GLint, GLint )
    maxParam = 4;
    READ_ENUM_PARAM(0);
    READ_PARAM(v32bit,1);
    READ_PARAM(v32bit,2);
    READ_PARAM(v32bit,3);
    TR.skipLine();
    CHECK_USER_CALL(glVertexAttribI3iEXT)
        UCT.glVertexAttribI3iEXT(param[0].uv32bit, param[1].v32bit, param[2].v32bit, param[3].v32bit);
    CHECK_GL_CALL(glVertexAttribI3iEXT)
        JT.glVertexAttribI3iEXT(param[0].uv32bit, param[1].v32bit, param[2].v32bit, param[3].v32bit);
}

void STUB_glVertexAttribI3iv( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glVertexAttribI3iv( GLuint, const GLint * )
    maxParam = 2;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ARRAY_PARAM( 1, buffer0, TraceReader::TEXT_INT);
    TR.skipLine();
    CHECK_USER_CALL(glVertexAttribI3iv)
        UCT.glVertexAttribI3iv(param[0].uv32bit, (const GLint *)param[1].ptr);
    CHECK_GL_CALL(glVertexAttribI3iv)
        JT.glVertexAttribI3iv(param[0].uv32bit, (const GLint *)param[1].ptr);
}

void STUB_glVertexAttribI3ivEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glVertexAttribI3ivEXT( GLuint, const GLint * )
    maxParam = 2;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ARRAY_PARAM( 1, buffer0, TraceReader::TEXT_INT);
    TR.skipLine();
    CHECK_USER_CALL(glVertexAttribI3ivEXT)
        UCT.glVertexAttribI3ivEXT(param[0].uv32bit, (const GLint *)param[1].ptr);
    CHECK_GL_CALL(glVertexAttribI3ivEXT)
        JT.glVertexAttribI3ivEXT(param[0].uv32bit, (const GLint *)param[1].ptr);
}

void STUB_glVertexAttribI3ui( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glVertexAttribI3ui( GLuint, GLuint, GLuint, GLuint )
    maxParam = 4;
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_ENUM_PARAM(2);
    READ_ENUM_PARAM(3);
    TR.skipLine();
    CHECK_USER_CALL(glVertexAttribI3ui)
        UCT.glVertexAttribI3ui(param[0].uv32bit, param[1].uv32bit, param[2].uv32bit, param[3].uv32bit);
    CHECK_GL_CALL(glVertexAttribI3ui)
        JT.glVertexAttribI3ui(param[0].uv32bit, param[1].uv32bit, param[2].uv32bit, param[3].uv32bit);
}

void STUB_glVertexAttribI3uiEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glVertexAttribI3uiEXT( GLuint, GLuint, GLuint, GLuint )
    maxParam = 4;
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_ENUM_PARAM(2);
    READ_ENUM_PARAM(3);
    TR.skipLine();
    CHECK_USER_CALL(glVertexAttribI3uiEXT)
        UCT.glVertexAttribI3uiEXT(param[0].uv32bit, param[1].uv32bit, param[2].uv32bit, param[3].uv32bit);
    CHECK_GL_CALL(glVertexAttribI3uiEXT)
        JT.glVertexAttribI3uiEXT(param[0].uv32bit, param[1].uv32bit, param[2].uv32bit, param[3].uv32bit);
}

void STUB_glVertexAttribI3uiv( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glVertexAttribI3uiv( GLuint, const GLuint * )
    maxParam = 2;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ARRAY_PARAM( 1, buffer0, TraceReader::TEXT_INT);
    TR.skipLine();
    CHECK_USER_CALL(glVertexAttribI3uiv)
        UCT.glVertexAttribI3uiv(param[0].uv32bit, (const GLuint *)param[1].ptr);
    CHECK_GL_CALL(glVertexAttribI3uiv)
        JT.glVertexAttribI3uiv(param[0].uv32bit, (const GLuint *)param[1].ptr);
}

void STUB_glVertexAttribI3uivEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glVertexAttribI3uivEXT( GLuint, const GLuint * )
    maxParam = 2;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ARRAY_PARAM( 1, buffer0, TraceReader::TEXT_INT);
    TR.skipLine();
    CHECK_USER_CALL(glVertexAttribI3uivEXT)
        UCT.glVertexAttribI3uivEXT(param[0].uv32bit, (const GLuint *)param[1].ptr);
    CHECK_GL_CALL(glVertexAttribI3uivEXT)
        JT.glVertexAttribI3uivEXT(param[0].uv32bit, (const GLuint *)param[1].ptr);
}

void STUB_glVertexAttribI4bv( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glVertexAttribI4bv( GLuint, const GLbyte * )
    maxParam = 2;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ARRAY_PARAM( 1, buffer0, TraceReader::TEXT_BYTE);
    TR.skipLine();
    CHECK_USER_CALL(glVertexAttribI4bv)
        UCT.glVertexAttribI4bv(param[0].uv32bit, (const GLbyte *)param[1].ptr);
    CHECK_GL_CALL(glVertexAttribI4bv)
        JT.glVertexAttribI4bv(param[0].uv32bit, (const GLbyte *)param[1].ptr);
}

void STUB_glVertexAttribI4bvEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glVertexAttribI4bvEXT( GLuint, const GLbyte * )
    maxParam = 2;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ARRAY_PARAM( 1, buffer0, TraceReader::TEXT_BYTE);
    TR.skipLine();
    CHECK_USER_CALL(glVertexAttribI4bvEXT)
        UCT.glVertexAttribI4bvEXT(param[0].uv32bit, (const GLbyte *)param[1].ptr);
    CHECK_GL_CALL(glVertexAttribI4bvEXT)
        JT.glVertexAttribI4bvEXT(param[0].uv32bit, (const GLbyte *)param[1].ptr);
}

void STUB_glVertexAttribI4i( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glVertexAttribI4i( GLuint, GLint, GLint, GLint, GLint )
    maxParam = 5;
    READ_ENUM_PARAM(0);
    READ_PARAM(v32bit,1);
    READ_PARAM(v32bit,2);
    READ_PARAM(v32bit,3);
    READ_PARAM(v32bit,4);
    TR.skipLine();
    CHECK_USER_CALL(glVertexAttribI4i)
        UCT.glVertexAttribI4i(param[0].uv32bit, param[1].v32bit, param[2].v32bit, param[3].v32bit, param[4].v32bit);
    CHECK_GL_CALL(glVertexAttribI4i)
        JT.glVertexAttribI4i(param[0].uv32bit, param[1].v32bit, param[2].v32bit, param[3].v32bit, param[4].v32bit);
}

void STUB_glVertexAttribI4iEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glVertexAttribI4iEXT( GLuint, GLint, GLint, GLint, GLint )
    maxParam = 5;
    READ_ENUM_PARAM(0);
    READ_PARAM(v32bit,1);
    READ_PARAM(v32bit,2);
    READ_PARAM(v32bit,3);
    READ_PARAM(v32bit,4);
    TR.skipLine();
    CHECK_USER_CALL(glVertexAttribI4iEXT)
        UCT.glVertexAttribI4iEXT(param[0].uv32bit, param[1].v32bit, param[2].v32bit, param[3].v32bit, param[4].v32bit);
    CHECK_GL_CALL(glVertexAttribI4iEXT)
        JT.glVertexAttribI4iEXT(param[0].uv32bit, param[1].v32bit, param[2].v32bit, param[3].v32bit, param[4].v32bit);
}

void STUB_glVertexAttribI4iv( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glVertexAttribI4iv( GLuint, const GLint * )
    maxParam = 2;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ARRAY_PARAM( 1, buffer0, TraceReader::TEXT_INT);
    TR.skipLine();
    CHECK_USER_CALL(glVertexAttribI4iv)
        UCT.glVertexAttribI4iv(param[0].uv32bit, (const GLint *)param[1].ptr);
    CHECK_GL_CALL(glVertexAttribI4iv)
        JT.glVertexAttribI4iv(param[0].uv32bit, (const GLint *)param[1].ptr);
}

void STUB_glVertexAttribI4ivEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glVertexAttribI4ivEXT( GLuint, const GLint * )
    maxParam = 2;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ARRAY_PARAM( 1, buffer0, TraceReader::TEXT_INT);
    TR.skipLine();
    CHECK_USER_CALL(glVertexAttribI4ivEXT)
        UCT.glVertexAttribI4ivEXT(param[0].uv32bit, (const GLint *)param[1].ptr);
    CHECK_GL_CALL(glVertexAttribI4ivEXT)
        JT.glVertexAttribI4ivEXT(param[0].uv32bit, (const GLint *)param[1].ptr);
}

void STUB_glVertexAttribI4sv( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glVertexAttribI4sv( GLuint, const GLshort * )
    maxParam = 2;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ARRAY_PARAM( 1, buffer0, TraceReader::TEXT_SHORT);
    TR.skipLine();
    CHECK_USER_CALL(glVertexAttribI4sv)
        UCT.glVertexAttribI4sv(param[0].uv32bit, (const GLshort *)param[1].ptr);
    CHECK_GL_CALL(glVertexAttribI4sv)
        JT.glVertexAttribI4sv(param[0].uv32bit, (const GLshort *)param[1].ptr);
}

void STUB_glVertexAttribI4svEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glVertexAttribI4svEXT( GLuint, const GLshort * )
    maxParam = 2;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ARRAY_PARAM( 1, buffer0, TraceReader::TEXT_SHORT);
    TR.skipLine();
    CHECK_USER_CALL(glVertexAttribI4svEXT)
        UCT.glVertexAttribI4svEXT(param[0].uv32bit, (const GLshort *)param[1].ptr);
    CHECK_GL_CALL(glVertexAttribI4svEXT)
        JT.glVertexAttribI4svEXT(param[0].uv32bit, (const GLshort *)param[1].ptr);
}

void STUB_glVertexAttribI4ubv( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glVertexAttribI4ubv( GLuint, const GLubyte * )
    maxParam = 2;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ARRAY_PARAM( 1, buffer0, TraceReader::TEXT_BYTE);
    TR.skipLine();
    CHECK_USER_CALL(glVertexAttribI4ubv)
        UCT.glVertexAttribI4ubv(param[0].uv32bit, (const GLubyte *)param[1].ptr);
    CHECK_GL_CALL(glVertexAttribI4ubv)
        JT.glVertexAttribI4ubv(param[0].uv32bit, (const GLubyte *)param[1].ptr);
}

void STUB_glVertexAttribI4ubvEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glVertexAttribI4ubvEXT( GLuint, const GLubyte * )
    maxParam = 2;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ARRAY_PARAM( 1, buffer0, TraceReader::TEXT_BYTE);
    TR.skipLine();
    CHECK_USER_CALL(glVertexAttribI4ubvEXT)
        UCT.glVertexAttribI4ubvEXT(param[0].uv32bit, (const GLubyte *)param[1].ptr);
    CHECK_GL_CALL(glVertexAttribI4ubvEXT)
        JT.glVertexAttribI4ubvEXT(param[0].uv32bit, (const GLubyte *)param[1].ptr);
}

void STUB_glVertexAttribI4ui( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glVertexAttribI4ui( GLuint, GLuint, GLuint, GLuint, GLuint )
    maxParam = 5;
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_ENUM_PARAM(2);
    READ_ENUM_PARAM(3);
    READ_ENUM_PARAM(4);
    TR.skipLine();
    CHECK_USER_CALL(glVertexAttribI4ui)
        UCT.glVertexAttribI4ui(param[0].uv32bit, param[1].uv32bit, param[2].uv32bit, param[3].uv32bit, param[4].uv32bit);
    CHECK_GL_CALL(glVertexAttribI4ui)
        JT.glVertexAttribI4ui(param[0].uv32bit, param[1].uv32bit, param[2].uv32bit, param[3].uv32bit, param[4].uv32bit);
}

void STUB_glVertexAttribI4uiEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glVertexAttribI4uiEXT( GLuint, GLuint, GLuint, GLuint, GLuint )
    maxParam = 5;
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_ENUM_PARAM(2);
    READ_ENUM_PARAM(3);
    READ_ENUM_PARAM(4);
    TR.skipLine();
    CHECK_USER_CALL(glVertexAttribI4uiEXT)
        UCT.glVertexAttribI4uiEXT(param[0].uv32bit, param[1].uv32bit, param[2].uv32bit, param[3].uv32bit, param[4].uv32bit);
    CHECK_GL_CALL(glVertexAttribI4uiEXT)
        JT.glVertexAttribI4uiEXT(param[0].uv32bit, param[1].uv32bit, param[2].uv32bit, param[3].uv32bit, param[4].uv32bit);
}

void STUB_glVertexAttribI4uiv( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glVertexAttribI4uiv( GLuint, const GLuint * )
    maxParam = 2;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ARRAY_PARAM( 1, buffer0, TraceReader::TEXT_INT);
    TR.skipLine();
    CHECK_USER_CALL(glVertexAttribI4uiv)
        UCT.glVertexAttribI4uiv(param[0].uv32bit, (const GLuint *)param[1].ptr);
    CHECK_GL_CALL(glVertexAttribI4uiv)
        JT.glVertexAttribI4uiv(param[0].uv32bit, (const GLuint *)param[1].ptr);
}

void STUB_glVertexAttribI4uivEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glVertexAttribI4uivEXT( GLuint, const GLuint * )
    maxParam = 2;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ARRAY_PARAM( 1, buffer0, TraceReader::TEXT_INT);
    TR.skipLine();
    CHECK_USER_CALL(glVertexAttribI4uivEXT)
        UCT.glVertexAttribI4uivEXT(param[0].uv32bit, (const GLuint *)param[1].ptr);
    CHECK_GL_CALL(glVertexAttribI4uivEXT)
        JT.glVertexAttribI4uivEXT(param[0].uv32bit, (const GLuint *)param[1].ptr);
}

void STUB_glVertexAttribI4usv( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glVertexAttribI4usv( GLuint, const GLushort * )
    maxParam = 2;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ARRAY_PARAM( 1, buffer0, TraceReader::TEXT_SHORT);
    TR.skipLine();
    CHECK_USER_CALL(glVertexAttribI4usv)
        UCT.glVertexAttribI4usv(param[0].uv32bit, (const GLushort *)param[1].ptr);
    CHECK_GL_CALL(glVertexAttribI4usv)
        JT.glVertexAttribI4usv(param[0].uv32bit, (const GLushort *)param[1].ptr);
}

void STUB_glVertexAttribI4usvEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glVertexAttribI4usvEXT( GLuint, const GLushort * )
    maxParam = 2;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ARRAY_PARAM( 1, buffer0, TraceReader::TEXT_SHORT);
    TR.skipLine();
    CHECK_USER_CALL(glVertexAttribI4usvEXT)
        UCT.glVertexAttribI4usvEXT(param[0].uv32bit, (const GLushort *)param[1].ptr);
    CHECK_GL_CALL(glVertexAttribI4usvEXT)
        JT.glVertexAttribI4usvEXT(param[0].uv32bit, (const GLushort *)param[1].ptr);
}

void STUB_glVertexAttribIPointer( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glVertexAttribIPointer( GLuint, GLint, GLenum, GLsizei, const GLvoid * )
    maxParam = 5;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_PARAM(v32bit,1);
    READ_ENUM_PARAM(2);
    READ_PARAM(v32bit,3);
    READ_ARRAY_PARAM( 4, buffer0, TraceReader::TEXT_IGNORE);
    TR.skipLine();
    CHECK_USER_CALL(glVertexAttribIPointer)
        UCT.glVertexAttribIPointer(param[0].uv32bit, param[1].v32bit, param[2].uv32bit, param[3].v32bit, (const GLvoid *)param[4].ptr);
    CHECK_GL_CALL(glVertexAttribIPointer)
        JT.glVertexAttribIPointer(param[0].uv32bit, param[1].v32bit, param[2].uv32bit, param[3].v32bit, (const GLvoid *)param[4].ptr);
}

void STUB_glVertexAttribIPointerEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glVertexAttribIPointerEXT( GLuint, GLint, GLenum, GLsizei, const GLvoid * )
    maxParam = 5;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_PARAM(v32bit,1);
    READ_ENUM_PARAM(2);
    READ_PARAM(v32bit,3);
    READ_ARRAY_PARAM( 4, buffer0, TraceReader::TEXT_IGNORE);
    TR.skipLine();
    CHECK_USER_CALL(glVertexAttribIPointerEXT)
        UCT.glVertexAttribIPointerEXT(param[0].uv32bit, param[1].v32bit, param[2].uv32bit, param[3].v32bit, (const GLvoid *)param[4].ptr);
    CHECK_GL_CALL(glVertexAttribIPointerEXT)
        JT.glVertexAttribIPointerEXT(param[0].uv32bit, param[1].v32bit, param[2].uv32bit, param[3].v32bit, (const GLvoid *)param[4].ptr);
}

void STUB_glVertexAttribPointer( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glVertexAttribPointer( GLuint, GLint, GLenum, GLboolean, GLsizei, const GLvoid * )
    maxParam = 6;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_PARAM(v32bit,1);
    READ_ENUM_PARAM(2);
    READ_BOOLEAN_PARAM(3);
    READ_PARAM(v32bit,4);
    READ_ARRAY_PARAM( 5, buffer0, TraceReader::TEXT_IGNORE);
    TR.skipLine();
    CHECK_USER_CALL(glVertexAttribPointer)
        UCT.glVertexAttribPointer(param[0].uv32bit, param[1].v32bit, param[2].uv32bit, param[3].boolean, param[4].v32bit, (const GLvoid *)param[5].ptr);
    CHECK_GL_CALL(glVertexAttribPointer)
        JT.glVertexAttribPointer(param[0].uv32bit, param[1].v32bit, param[2].uv32bit, param[3].boolean, param[4].v32bit, (const GLvoid *)param[5].ptr);
}

void STUB_glVertexAttribPointerARB( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glVertexAttribPointerARB( GLuint, GLint, GLenum, GLboolean, GLsizei, const GLvoid * )
    maxParam = 6;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_PARAM(v32bit,1);
    READ_ENUM_PARAM(2);
    READ_BOOLEAN_PARAM(3);
    READ_PARAM(v32bit,4);
    READ_ARRAY_PARAM( 5, buffer0, TraceReader::TEXT_IGNORE);
    TR.skipLine();
    CHECK_USER_CALL(glVertexAttribPointerARB)
        UCT.glVertexAttribPointerARB(param[0].uv32bit, param[1].v32bit, param[2].uv32bit, param[3].boolean, param[4].v32bit, (const GLvoid *)param[5].ptr);
    CHECK_GL_CALL(glVertexAttribPointerARB)
        JT.glVertexAttribPointerARB(param[0].uv32bit, param[1].v32bit, param[2].uv32bit, param[3].boolean, param[4].v32bit, (const GLvoid *)param[5].ptr);
}

void STUB_glVertexAttribPointerNV( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glVertexAttribPointerNV( GLuint, GLint, GLenum, GLsizei, const GLvoid * )
    maxParam = 5;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_PARAM(v32bit,1);
    READ_ENUM_PARAM(2);
    READ_PARAM(v32bit,3);
    READ_ARRAY_PARAM( 4, buffer0, TraceReader::TEXT_IGNORE);
    TR.skipLine();
    CHECK_USER_CALL(glVertexAttribPointerNV)
        UCT.glVertexAttribPointerNV(param[0].uv32bit, param[1].v32bit, param[2].uv32bit, param[3].v32bit, (const GLvoid *)param[4].ptr);
    CHECK_GL_CALL(glVertexAttribPointerNV)
        JT.glVertexAttribPointerNV(param[0].uv32bit, param[1].v32bit, param[2].uv32bit, param[3].v32bit, (const GLvoid *)param[4].ptr);
}

void STUB_glVertexAttribs1dvNV( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glVertexAttribs1dvNV( GLuint, GLsizei, const GLdouble * )
    maxParam = 3;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_PARAM(v32bit,1);
    READ_ARRAY_PARAM( 2, buffer0, TraceReader::TEXT_DOUBLE);
    TR.skipLine();
    CHECK_USER_CALL(glVertexAttribs1dvNV)
        UCT.glVertexAttribs1dvNV(param[0].uv32bit, param[1].v32bit, (const GLdouble *)param[2].ptr);
    CHECK_GL_CALL(glVertexAttribs1dvNV)
        JT.glVertexAttribs1dvNV(param[0].uv32bit, param[1].v32bit, (const GLdouble *)param[2].ptr);
}

void STUB_glVertexAttribs1fvNV( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glVertexAttribs1fvNV( GLuint, GLsizei, const GLfloat * )
    maxParam = 3;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_PARAM(v32bit,1);
    READ_ARRAY_PARAM( 2, buffer0, TraceReader::TEXT_FLOAT);
    TR.skipLine();
    CHECK_USER_CALL(glVertexAttribs1fvNV)
        UCT.glVertexAttribs1fvNV(param[0].uv32bit, param[1].v32bit, (const GLfloat *)param[2].ptr);
    CHECK_GL_CALL(glVertexAttribs1fvNV)
        JT.glVertexAttribs1fvNV(param[0].uv32bit, param[1].v32bit, (const GLfloat *)param[2].ptr);
}

void STUB_glVertexAttribs1hvNV( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glVertexAttribs1hvNV( GLuint, GLsizei, const GLhalfNV * )
    // Call not playable
    TR.skipCall();
}

void STUB_glVertexAttribs1svNV( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glVertexAttribs1svNV( GLuint, GLsizei, const GLshort * )
    maxParam = 3;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_PARAM(v32bit,1);
    READ_ARRAY_PARAM( 2, buffer0, TraceReader::TEXT_SHORT);
    TR.skipLine();
    CHECK_USER_CALL(glVertexAttribs1svNV)
        UCT.glVertexAttribs1svNV(param[0].uv32bit, param[1].v32bit, (const GLshort *)param[2].ptr);
    CHECK_GL_CALL(glVertexAttribs1svNV)
        JT.glVertexAttribs1svNV(param[0].uv32bit, param[1].v32bit, (const GLshort *)param[2].ptr);
}

void STUB_glVertexAttribs2dvNV( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glVertexAttribs2dvNV( GLuint, GLsizei, const GLdouble * )
    maxParam = 3;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_PARAM(v32bit,1);
    READ_ARRAY_PARAM( 2, buffer0, TraceReader::TEXT_DOUBLE);
    TR.skipLine();
    CHECK_USER_CALL(glVertexAttribs2dvNV)
        UCT.glVertexAttribs2dvNV(param[0].uv32bit, param[1].v32bit, (const GLdouble *)param[2].ptr);
    CHECK_GL_CALL(glVertexAttribs2dvNV)
        JT.glVertexAttribs2dvNV(param[0].uv32bit, param[1].v32bit, (const GLdouble *)param[2].ptr);
}

void STUB_glVertexAttribs2fvNV( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glVertexAttribs2fvNV( GLuint, GLsizei, const GLfloat * )
    maxParam = 3;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_PARAM(v32bit,1);
    READ_ARRAY_PARAM( 2, buffer0, TraceReader::TEXT_FLOAT);
    TR.skipLine();
    CHECK_USER_CALL(glVertexAttribs2fvNV)
        UCT.glVertexAttribs2fvNV(param[0].uv32bit, param[1].v32bit, (const GLfloat *)param[2].ptr);
    CHECK_GL_CALL(glVertexAttribs2fvNV)
        JT.glVertexAttribs2fvNV(param[0].uv32bit, param[1].v32bit, (const GLfloat *)param[2].ptr);
}

void STUB_glVertexAttribs2hvNV( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glVertexAttribs2hvNV( GLuint, GLsizei, const GLhalfNV * )
    // Call not playable
    TR.skipCall();
}

void STUB_glVertexAttribs2svNV( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glVertexAttribs2svNV( GLuint, GLsizei, const GLshort * )
    maxParam = 3;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_PARAM(v32bit,1);
    READ_ARRAY_PARAM( 2, buffer0, TraceReader::TEXT_SHORT);
    TR.skipLine();
    CHECK_USER_CALL(glVertexAttribs2svNV)
        UCT.glVertexAttribs2svNV(param[0].uv32bit, param[1].v32bit, (const GLshort *)param[2].ptr);
    CHECK_GL_CALL(glVertexAttribs2svNV)
        JT.glVertexAttribs2svNV(param[0].uv32bit, param[1].v32bit, (const GLshort *)param[2].ptr);
}

void STUB_glVertexAttribs3dvNV( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glVertexAttribs3dvNV( GLuint, GLsizei, const GLdouble * )
    maxParam = 3;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_PARAM(v32bit,1);
    READ_ARRAY_PARAM( 2, buffer0, TraceReader::TEXT_DOUBLE);
    TR.skipLine();
    CHECK_USER_CALL(glVertexAttribs3dvNV)
        UCT.glVertexAttribs3dvNV(param[0].uv32bit, param[1].v32bit, (const GLdouble *)param[2].ptr);
    CHECK_GL_CALL(glVertexAttribs3dvNV)
        JT.glVertexAttribs3dvNV(param[0].uv32bit, param[1].v32bit, (const GLdouble *)param[2].ptr);
}

void STUB_glVertexAttribs3fvNV( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glVertexAttribs3fvNV( GLuint, GLsizei, const GLfloat * )
    maxParam = 3;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_PARAM(v32bit,1);
    READ_ARRAY_PARAM( 2, buffer0, TraceReader::TEXT_FLOAT);
    TR.skipLine();
    CHECK_USER_CALL(glVertexAttribs3fvNV)
        UCT.glVertexAttribs3fvNV(param[0].uv32bit, param[1].v32bit, (const GLfloat *)param[2].ptr);
    CHECK_GL_CALL(glVertexAttribs3fvNV)
        JT.glVertexAttribs3fvNV(param[0].uv32bit, param[1].v32bit, (const GLfloat *)param[2].ptr);
}

void STUB_glVertexAttribs3hvNV( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glVertexAttribs3hvNV( GLuint, GLsizei, const GLhalfNV * )
    // Call not playable
    TR.skipCall();
}

void STUB_glVertexAttribs3svNV( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glVertexAttribs3svNV( GLuint, GLsizei, const GLshort * )
    maxParam = 3;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_PARAM(v32bit,1);
    READ_ARRAY_PARAM( 2, buffer0, TraceReader::TEXT_SHORT);
    TR.skipLine();
    CHECK_USER_CALL(glVertexAttribs3svNV)
        UCT.glVertexAttribs3svNV(param[0].uv32bit, param[1].v32bit, (const GLshort *)param[2].ptr);
    CHECK_GL_CALL(glVertexAttribs3svNV)
        JT.glVertexAttribs3svNV(param[0].uv32bit, param[1].v32bit, (const GLshort *)param[2].ptr);
}

void STUB_glVertexAttribs4dvNV( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glVertexAttribs4dvNV( GLuint, GLsizei, const GLdouble * )
    maxParam = 3;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_PARAM(v32bit,1);
    READ_ARRAY_PARAM( 2, buffer0, TraceReader::TEXT_DOUBLE);
    TR.skipLine();
    CHECK_USER_CALL(glVertexAttribs4dvNV)
        UCT.glVertexAttribs4dvNV(param[0].uv32bit, param[1].v32bit, (const GLdouble *)param[2].ptr);
    CHECK_GL_CALL(glVertexAttribs4dvNV)
        JT.glVertexAttribs4dvNV(param[0].uv32bit, param[1].v32bit, (const GLdouble *)param[2].ptr);
}

void STUB_glVertexAttribs4fvNV( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glVertexAttribs4fvNV( GLuint, GLsizei, const GLfloat * )
    maxParam = 3;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_PARAM(v32bit,1);
    READ_ARRAY_PARAM( 2, buffer0, TraceReader::TEXT_FLOAT);
    TR.skipLine();
    CHECK_USER_CALL(glVertexAttribs4fvNV)
        UCT.glVertexAttribs4fvNV(param[0].uv32bit, param[1].v32bit, (const GLfloat *)param[2].ptr);
    CHECK_GL_CALL(glVertexAttribs4fvNV)
        JT.glVertexAttribs4fvNV(param[0].uv32bit, param[1].v32bit, (const GLfloat *)param[2].ptr);
}

void STUB_glVertexAttribs4hvNV( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glVertexAttribs4hvNV( GLuint, GLsizei, const GLhalfNV * )
    // Call not playable
    TR.skipCall();
}

void STUB_glVertexAttribs4svNV( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glVertexAttribs4svNV( GLuint, GLsizei, const GLshort * )
    maxParam = 3;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_PARAM(v32bit,1);
    READ_ARRAY_PARAM( 2, buffer0, TraceReader::TEXT_SHORT);
    TR.skipLine();
    CHECK_USER_CALL(glVertexAttribs4svNV)
        UCT.glVertexAttribs4svNV(param[0].uv32bit, param[1].v32bit, (const GLshort *)param[2].ptr);
    CHECK_GL_CALL(glVertexAttribs4svNV)
        JT.glVertexAttribs4svNV(param[0].uv32bit, param[1].v32bit, (const GLshort *)param[2].ptr);
}

void STUB_glVertexAttribs4ubvNV( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glVertexAttribs4ubvNV( GLuint, GLsizei, const GLubyte * )
    maxParam = 3;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_PARAM(v32bit,1);
    READ_ARRAY_PARAM( 2, buffer0, TraceReader::TEXT_BYTE);
    TR.skipLine();
    CHECK_USER_CALL(glVertexAttribs4ubvNV)
        UCT.glVertexAttribs4ubvNV(param[0].uv32bit, param[1].v32bit, (const GLubyte *)param[2].ptr);
    CHECK_GL_CALL(glVertexAttribs4ubvNV)
        JT.glVertexAttribs4ubvNV(param[0].uv32bit, param[1].v32bit, (const GLubyte *)param[2].ptr);
}

void STUB_glVertexBlendARB( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glVertexBlendARB( GLint )
    maxParam = 1;
    READ_PARAM(v32bit,0);
    TR.skipLine();
    CHECK_USER_CALL(glVertexBlendARB)
        UCT.glVertexBlendARB(param[0].v32bit);
    CHECK_GL_CALL(glVertexBlendARB)
        JT.glVertexBlendARB(param[0].v32bit);
}

void STUB_glVertexBlendEnvfATI( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glVertexBlendEnvfATI( GLenum, GLfloat )
    maxParam = 2;
    READ_ENUM_PARAM(0);
    READ_PARAM(fv32bit,1);
    TR.skipLine();
    CHECK_USER_CALL(glVertexBlendEnvfATI)
        UCT.glVertexBlendEnvfATI(param[0].uv32bit, param[1].fv32bit);
    CHECK_GL_CALL(glVertexBlendEnvfATI)
        JT.glVertexBlendEnvfATI(param[0].uv32bit, param[1].fv32bit);
}

void STUB_glVertexBlendEnviATI( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glVertexBlendEnviATI( GLenum, GLint )
    maxParam = 2;
    READ_ENUM_PARAM(0);
    READ_PARAM(v32bit,1);
    TR.skipLine();
    CHECK_USER_CALL(glVertexBlendEnviATI)
        UCT.glVertexBlendEnviATI(param[0].uv32bit, param[1].v32bit);
    CHECK_GL_CALL(glVertexBlendEnviATI)
        JT.glVertexBlendEnviATI(param[0].uv32bit, param[1].v32bit);
}

void STUB_glVertexPointer( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glVertexPointer( GLint size, GLenum type, GLsizei stride, const GLvoid *ptr )
    maxParam = 4;
    char buffer0[16*4096];
    READ_PARAM(v32bit,0);
    READ_ENUM_PARAM(1);
    READ_PARAM(v32bit,2);
    READ_ARRAY_PARAM( 3, buffer0, TraceReader::TEXT_IGNORE);
    TR.skipLine();
    CHECK_USER_CALL(glVertexPointer)
        UCT.glVertexPointer(param[0].v32bit, param[1].uv32bit, param[2].v32bit, (const GLvoid *)param[3].ptr);
    CHECK_GL_CALL(glVertexPointer)
        JT.glVertexPointer(param[0].v32bit, param[1].uv32bit, param[2].v32bit, (const GLvoid *)param[3].ptr);
}

void STUB_glVertexPointerEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glVertexPointerEXT( GLint, GLenum, GLsizei, GLsizei, const GLvoid * )
    maxParam = 5;
    char buffer0[16*4096];
    READ_PARAM(v32bit,0);
    READ_ENUM_PARAM(1);
    READ_PARAM(v32bit,2);
    READ_PARAM(v32bit,3);
    READ_ARRAY_PARAM( 4, buffer0, TraceReader::TEXT_IGNORE);
    TR.skipLine();
    CHECK_USER_CALL(glVertexPointerEXT)
        UCT.glVertexPointerEXT(param[0].v32bit, param[1].uv32bit, param[2].v32bit, param[3].v32bit, (const GLvoid *)param[4].ptr);
    CHECK_GL_CALL(glVertexPointerEXT)
        JT.glVertexPointerEXT(param[0].v32bit, param[1].uv32bit, param[2].v32bit, param[3].v32bit, (const GLvoid *)param[4].ptr);
}

void STUB_glVertexPointervINTEL( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glVertexPointervINTEL( GLint, GLenum, const GLvoid ** )
    maxParam = 3;
    char buffer0[16*4096];
    READ_PARAM(v32bit,0);
    READ_ENUM_PARAM(1);
    READ_ARRAY_PARAM( 2, buffer0, TraceReader::TEXT_IGNORE);
    TR.skipLine();
    CHECK_USER_CALL(glVertexPointervINTEL)
        UCT.glVertexPointervINTEL(param[0].v32bit, param[1].uv32bit, (const GLvoid **)param[2].ptr);
    CHECK_GL_CALL(glVertexPointervINTEL)
        JT.glVertexPointervINTEL(param[0].v32bit, param[1].uv32bit, (const GLvoid **)param[2].ptr);
}

void STUB_glVertexStream1dATI( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glVertexStream1dATI( GLenum, GLdouble )
    maxParam = 2;
    READ_ENUM_PARAM(0);
    READ_DOUBLE_PARAM(1);
    TR.skipLine();
    CHECK_USER_CALL(glVertexStream1dATI)
        UCT.glVertexStream1dATI(param[0].uv32bit, param[1].fv64bit);
    CHECK_GL_CALL(glVertexStream1dATI)
        JT.glVertexStream1dATI(param[0].uv32bit, param[1].fv64bit);
}

void STUB_glVertexStream1dvATI( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glVertexStream1dvATI( GLenum, const GLdouble * )
    maxParam = 2;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ARRAY_PARAM( 1, buffer0, TraceReader::TEXT_DOUBLE);
    TR.skipLine();
    CHECK_USER_CALL(glVertexStream1dvATI)
        UCT.glVertexStream1dvATI(param[0].uv32bit, (const GLdouble *)param[1].ptr);
    CHECK_GL_CALL(glVertexStream1dvATI)
        JT.glVertexStream1dvATI(param[0].uv32bit, (const GLdouble *)param[1].ptr);
}

void STUB_glVertexStream1fATI( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glVertexStream1fATI( GLenum, GLfloat )
    maxParam = 2;
    READ_ENUM_PARAM(0);
    READ_PARAM(fv32bit,1);
    TR.skipLine();
    CHECK_USER_CALL(glVertexStream1fATI)
        UCT.glVertexStream1fATI(param[0].uv32bit, param[1].fv32bit);
    CHECK_GL_CALL(glVertexStream1fATI)
        JT.glVertexStream1fATI(param[0].uv32bit, param[1].fv32bit);
}

void STUB_glVertexStream1fvATI( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glVertexStream1fvATI( GLenum, const GLfloat * )
    maxParam = 2;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ARRAY_PARAM( 1, buffer0, TraceReader::TEXT_FLOAT);
    TR.skipLine();
    CHECK_USER_CALL(glVertexStream1fvATI)
        UCT.glVertexStream1fvATI(param[0].uv32bit, (const GLfloat *)param[1].ptr);
    CHECK_GL_CALL(glVertexStream1fvATI)
        JT.glVertexStream1fvATI(param[0].uv32bit, (const GLfloat *)param[1].ptr);
}

void STUB_glVertexStream1iATI( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glVertexStream1iATI( GLenum, GLint )
    maxParam = 2;
    READ_ENUM_PARAM(0);
    READ_PARAM(v32bit,1);
    TR.skipLine();
    CHECK_USER_CALL(glVertexStream1iATI)
        UCT.glVertexStream1iATI(param[0].uv32bit, param[1].v32bit);
    CHECK_GL_CALL(glVertexStream1iATI)
        JT.glVertexStream1iATI(param[0].uv32bit, param[1].v32bit);
}

void STUB_glVertexStream1ivATI( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glVertexStream1ivATI( GLenum, const GLint * )
    maxParam = 2;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ARRAY_PARAM( 1, buffer0, TraceReader::TEXT_INT);
    TR.skipLine();
    CHECK_USER_CALL(glVertexStream1ivATI)
        UCT.glVertexStream1ivATI(param[0].uv32bit, (const GLint *)param[1].ptr);
    CHECK_GL_CALL(glVertexStream1ivATI)
        JT.glVertexStream1ivATI(param[0].uv32bit, (const GLint *)param[1].ptr);
}

void STUB_glVertexStream1sATI( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glVertexStream1sATI( GLenum, GLshort )
    maxParam = 2;
    READ_ENUM_PARAM(0);
    READ_PARAM(v16bit,1);
    TR.skipLine();
    CHECK_USER_CALL(glVertexStream1sATI)
        UCT.glVertexStream1sATI(param[0].uv32bit, param[1].v16bit);
    CHECK_GL_CALL(glVertexStream1sATI)
        JT.glVertexStream1sATI(param[0].uv32bit, param[1].v16bit);
}

void STUB_glVertexStream1svATI( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glVertexStream1svATI( GLenum, const GLshort * )
    maxParam = 2;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ARRAY_PARAM( 1, buffer0, TraceReader::TEXT_SHORT);
    TR.skipLine();
    CHECK_USER_CALL(glVertexStream1svATI)
        UCT.glVertexStream1svATI(param[0].uv32bit, (const GLshort *)param[1].ptr);
    CHECK_GL_CALL(glVertexStream1svATI)
        JT.glVertexStream1svATI(param[0].uv32bit, (const GLshort *)param[1].ptr);
}

void STUB_glVertexStream2dATI( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glVertexStream2dATI( GLenum, GLdouble, GLdouble )
    maxParam = 3;
    READ_ENUM_PARAM(0);
    READ_DOUBLE_PARAM(1);
    READ_DOUBLE_PARAM(2);
    TR.skipLine();
    CHECK_USER_CALL(glVertexStream2dATI)
        UCT.glVertexStream2dATI(param[0].uv32bit, param[1].fv64bit, param[2].fv64bit);
    CHECK_GL_CALL(glVertexStream2dATI)
        JT.glVertexStream2dATI(param[0].uv32bit, param[1].fv64bit, param[2].fv64bit);
}

void STUB_glVertexStream2dvATI( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glVertexStream2dvATI( GLenum, const GLdouble * )
    maxParam = 2;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ARRAY_PARAM( 1, buffer0, TraceReader::TEXT_DOUBLE);
    TR.skipLine();
    CHECK_USER_CALL(glVertexStream2dvATI)
        UCT.glVertexStream2dvATI(param[0].uv32bit, (const GLdouble *)param[1].ptr);
    CHECK_GL_CALL(glVertexStream2dvATI)
        JT.glVertexStream2dvATI(param[0].uv32bit, (const GLdouble *)param[1].ptr);
}

void STUB_glVertexStream2fATI( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glVertexStream2fATI( GLenum, GLfloat, GLfloat )
    maxParam = 3;
    READ_ENUM_PARAM(0);
    READ_PARAM(fv32bit,1);
    READ_PARAM(fv32bit,2);
    TR.skipLine();
    CHECK_USER_CALL(glVertexStream2fATI)
        UCT.glVertexStream2fATI(param[0].uv32bit, param[1].fv32bit, param[2].fv32bit);
    CHECK_GL_CALL(glVertexStream2fATI)
        JT.glVertexStream2fATI(param[0].uv32bit, param[1].fv32bit, param[2].fv32bit);
}

void STUB_glVertexStream2fvATI( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glVertexStream2fvATI( GLenum, const GLfloat * )
    maxParam = 2;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ARRAY_PARAM( 1, buffer0, TraceReader::TEXT_FLOAT);
    TR.skipLine();
    CHECK_USER_CALL(glVertexStream2fvATI)
        UCT.glVertexStream2fvATI(param[0].uv32bit, (const GLfloat *)param[1].ptr);
    CHECK_GL_CALL(glVertexStream2fvATI)
        JT.glVertexStream2fvATI(param[0].uv32bit, (const GLfloat *)param[1].ptr);
}

void STUB_glVertexStream2iATI( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glVertexStream2iATI( GLenum, GLint, GLint )
    maxParam = 3;
    READ_ENUM_PARAM(0);
    READ_PARAM(v32bit,1);
    READ_PARAM(v32bit,2);
    TR.skipLine();
    CHECK_USER_CALL(glVertexStream2iATI)
        UCT.glVertexStream2iATI(param[0].uv32bit, param[1].v32bit, param[2].v32bit);
    CHECK_GL_CALL(glVertexStream2iATI)
        JT.glVertexStream2iATI(param[0].uv32bit, param[1].v32bit, param[2].v32bit);
}

void STUB_glVertexStream2ivATI( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glVertexStream2ivATI( GLenum, const GLint * )
    maxParam = 2;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ARRAY_PARAM( 1, buffer0, TraceReader::TEXT_INT);
    TR.skipLine();
    CHECK_USER_CALL(glVertexStream2ivATI)
        UCT.glVertexStream2ivATI(param[0].uv32bit, (const GLint *)param[1].ptr);
    CHECK_GL_CALL(glVertexStream2ivATI)
        JT.glVertexStream2ivATI(param[0].uv32bit, (const GLint *)param[1].ptr);
}

void STUB_glVertexStream2sATI( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glVertexStream2sATI( GLenum, GLshort, GLshort )
    maxParam = 3;
    READ_ENUM_PARAM(0);
    READ_PARAM(v16bit,1);
    READ_PARAM(v16bit,2);
    TR.skipLine();
    CHECK_USER_CALL(glVertexStream2sATI)
        UCT.glVertexStream2sATI(param[0].uv32bit, param[1].v16bit, param[2].v16bit);
    CHECK_GL_CALL(glVertexStream2sATI)
        JT.glVertexStream2sATI(param[0].uv32bit, param[1].v16bit, param[2].v16bit);
}

void STUB_glVertexStream2svATI( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glVertexStream2svATI( GLenum, const GLshort * )
    maxParam = 2;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ARRAY_PARAM( 1, buffer0, TraceReader::TEXT_SHORT);
    TR.skipLine();
    CHECK_USER_CALL(glVertexStream2svATI)
        UCT.glVertexStream2svATI(param[0].uv32bit, (const GLshort *)param[1].ptr);
    CHECK_GL_CALL(glVertexStream2svATI)
        JT.glVertexStream2svATI(param[0].uv32bit, (const GLshort *)param[1].ptr);
}

void STUB_glVertexStream3dATI( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glVertexStream3dATI( GLenum, GLdouble, GLdouble, GLdouble )
    maxParam = 4;
    READ_ENUM_PARAM(0);
    READ_DOUBLE_PARAM(1);
    READ_DOUBLE_PARAM(2);
    READ_DOUBLE_PARAM(3);
    TR.skipLine();
    CHECK_USER_CALL(glVertexStream3dATI)
        UCT.glVertexStream3dATI(param[0].uv32bit, param[1].fv64bit, param[2].fv64bit, param[3].fv64bit);
    CHECK_GL_CALL(glVertexStream3dATI)
        JT.glVertexStream3dATI(param[0].uv32bit, param[1].fv64bit, param[2].fv64bit, param[3].fv64bit);
}

void STUB_glVertexStream3dvATI( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glVertexStream3dvATI( GLenum, const GLdouble * )
    maxParam = 2;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ARRAY_PARAM( 1, buffer0, TraceReader::TEXT_DOUBLE);
    TR.skipLine();
    CHECK_USER_CALL(glVertexStream3dvATI)
        UCT.glVertexStream3dvATI(param[0].uv32bit, (const GLdouble *)param[1].ptr);
    CHECK_GL_CALL(glVertexStream3dvATI)
        JT.glVertexStream3dvATI(param[0].uv32bit, (const GLdouble *)param[1].ptr);
}

void STUB_glVertexStream3fATI( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glVertexStream3fATI( GLenum, GLfloat, GLfloat, GLfloat )
    maxParam = 4;
    READ_ENUM_PARAM(0);
    READ_PARAM(fv32bit,1);
    READ_PARAM(fv32bit,2);
    READ_PARAM(fv32bit,3);
    TR.skipLine();
    CHECK_USER_CALL(glVertexStream3fATI)
        UCT.glVertexStream3fATI(param[0].uv32bit, param[1].fv32bit, param[2].fv32bit, param[3].fv32bit);
    CHECK_GL_CALL(glVertexStream3fATI)
        JT.glVertexStream3fATI(param[0].uv32bit, param[1].fv32bit, param[2].fv32bit, param[3].fv32bit);
}

void STUB_glVertexStream3fvATI( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glVertexStream3fvATI( GLenum, const GLfloat * )
    maxParam = 2;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ARRAY_PARAM( 1, buffer0, TraceReader::TEXT_FLOAT);
    TR.skipLine();
    CHECK_USER_CALL(glVertexStream3fvATI)
        UCT.glVertexStream3fvATI(param[0].uv32bit, (const GLfloat *)param[1].ptr);
    CHECK_GL_CALL(glVertexStream3fvATI)
        JT.glVertexStream3fvATI(param[0].uv32bit, (const GLfloat *)param[1].ptr);
}

void STUB_glVertexStream3iATI( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glVertexStream3iATI( GLenum, GLint, GLint, GLint )
    maxParam = 4;
    READ_ENUM_PARAM(0);
    READ_PARAM(v32bit,1);
    READ_PARAM(v32bit,2);
    READ_PARAM(v32bit,3);
    TR.skipLine();
    CHECK_USER_CALL(glVertexStream3iATI)
        UCT.glVertexStream3iATI(param[0].uv32bit, param[1].v32bit, param[2].v32bit, param[3].v32bit);
    CHECK_GL_CALL(glVertexStream3iATI)
        JT.glVertexStream3iATI(param[0].uv32bit, param[1].v32bit, param[2].v32bit, param[3].v32bit);
}

void STUB_glVertexStream3ivATI( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glVertexStream3ivATI( GLenum, const GLint * )
    maxParam = 2;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ARRAY_PARAM( 1, buffer0, TraceReader::TEXT_INT);
    TR.skipLine();
    CHECK_USER_CALL(glVertexStream3ivATI)
        UCT.glVertexStream3ivATI(param[0].uv32bit, (const GLint *)param[1].ptr);
    CHECK_GL_CALL(glVertexStream3ivATI)
        JT.glVertexStream3ivATI(param[0].uv32bit, (const GLint *)param[1].ptr);
}

void STUB_glVertexStream3sATI( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glVertexStream3sATI( GLenum, GLshort, GLshort, GLshort )
    maxParam = 4;
    READ_ENUM_PARAM(0);
    READ_PARAM(v16bit,1);
    READ_PARAM(v16bit,2);
    READ_PARAM(v16bit,3);
    TR.skipLine();
    CHECK_USER_CALL(glVertexStream3sATI)
        UCT.glVertexStream3sATI(param[0].uv32bit, param[1].v16bit, param[2].v16bit, param[3].v16bit);
    CHECK_GL_CALL(glVertexStream3sATI)
        JT.glVertexStream3sATI(param[0].uv32bit, param[1].v16bit, param[2].v16bit, param[3].v16bit);
}

void STUB_glVertexStream3svATI( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glVertexStream3svATI( GLenum, const GLshort * )
    maxParam = 2;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ARRAY_PARAM( 1, buffer0, TraceReader::TEXT_SHORT);
    TR.skipLine();
    CHECK_USER_CALL(glVertexStream3svATI)
        UCT.glVertexStream3svATI(param[0].uv32bit, (const GLshort *)param[1].ptr);
    CHECK_GL_CALL(glVertexStream3svATI)
        JT.glVertexStream3svATI(param[0].uv32bit, (const GLshort *)param[1].ptr);
}

void STUB_glVertexStream4dATI( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glVertexStream4dATI( GLenum, GLdouble, GLdouble, GLdouble, GLdouble )
    maxParam = 5;
    READ_ENUM_PARAM(0);
    READ_DOUBLE_PARAM(1);
    READ_DOUBLE_PARAM(2);
    READ_DOUBLE_PARAM(3);
    READ_DOUBLE_PARAM(4);
    TR.skipLine();
    CHECK_USER_CALL(glVertexStream4dATI)
        UCT.glVertexStream4dATI(param[0].uv32bit, param[1].fv64bit, param[2].fv64bit, param[3].fv64bit, param[4].fv64bit);
    CHECK_GL_CALL(glVertexStream4dATI)
        JT.glVertexStream4dATI(param[0].uv32bit, param[1].fv64bit, param[2].fv64bit, param[3].fv64bit, param[4].fv64bit);
}

void STUB_glVertexStream4dvATI( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glVertexStream4dvATI( GLenum, const GLdouble * )
    maxParam = 2;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ARRAY_PARAM( 1, buffer0, TraceReader::TEXT_DOUBLE);
    TR.skipLine();
    CHECK_USER_CALL(glVertexStream4dvATI)
        UCT.glVertexStream4dvATI(param[0].uv32bit, (const GLdouble *)param[1].ptr);
    CHECK_GL_CALL(glVertexStream4dvATI)
        JT.glVertexStream4dvATI(param[0].uv32bit, (const GLdouble *)param[1].ptr);
}

void STUB_glVertexStream4fATI( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glVertexStream4fATI( GLenum, GLfloat, GLfloat, GLfloat, GLfloat )
    maxParam = 5;
    READ_ENUM_PARAM(0);
    READ_PARAM(fv32bit,1);
    READ_PARAM(fv32bit,2);
    READ_PARAM(fv32bit,3);
    READ_PARAM(fv32bit,4);
    TR.skipLine();
    CHECK_USER_CALL(glVertexStream4fATI)
        UCT.glVertexStream4fATI(param[0].uv32bit, param[1].fv32bit, param[2].fv32bit, param[3].fv32bit, param[4].fv32bit);
    CHECK_GL_CALL(glVertexStream4fATI)
        JT.glVertexStream4fATI(param[0].uv32bit, param[1].fv32bit, param[2].fv32bit, param[3].fv32bit, param[4].fv32bit);
}

void STUB_glVertexStream4fvATI( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glVertexStream4fvATI( GLenum, const GLfloat * )
    maxParam = 2;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ARRAY_PARAM( 1, buffer0, TraceReader::TEXT_FLOAT);
    TR.skipLine();
    CHECK_USER_CALL(glVertexStream4fvATI)
        UCT.glVertexStream4fvATI(param[0].uv32bit, (const GLfloat *)param[1].ptr);
    CHECK_GL_CALL(glVertexStream4fvATI)
        JT.glVertexStream4fvATI(param[0].uv32bit, (const GLfloat *)param[1].ptr);
}

void STUB_glVertexStream4iATI( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glVertexStream4iATI( GLenum, GLint, GLint, GLint, GLint )
    maxParam = 5;
    READ_ENUM_PARAM(0);
    READ_PARAM(v32bit,1);
    READ_PARAM(v32bit,2);
    READ_PARAM(v32bit,3);
    READ_PARAM(v32bit,4);
    TR.skipLine();
    CHECK_USER_CALL(glVertexStream4iATI)
        UCT.glVertexStream4iATI(param[0].uv32bit, param[1].v32bit, param[2].v32bit, param[3].v32bit, param[4].v32bit);
    CHECK_GL_CALL(glVertexStream4iATI)
        JT.glVertexStream4iATI(param[0].uv32bit, param[1].v32bit, param[2].v32bit, param[3].v32bit, param[4].v32bit);
}

void STUB_glVertexStream4ivATI( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glVertexStream4ivATI( GLenum, const GLint * )
    maxParam = 2;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ARRAY_PARAM( 1, buffer0, TraceReader::TEXT_INT);
    TR.skipLine();
    CHECK_USER_CALL(glVertexStream4ivATI)
        UCT.glVertexStream4ivATI(param[0].uv32bit, (const GLint *)param[1].ptr);
    CHECK_GL_CALL(glVertexStream4ivATI)
        JT.glVertexStream4ivATI(param[0].uv32bit, (const GLint *)param[1].ptr);
}

void STUB_glVertexStream4sATI( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glVertexStream4sATI( GLenum, GLshort, GLshort, GLshort, GLshort )
    maxParam = 5;
    READ_ENUM_PARAM(0);
    READ_PARAM(v16bit,1);
    READ_PARAM(v16bit,2);
    READ_PARAM(v16bit,3);
    READ_PARAM(v16bit,4);
    TR.skipLine();
    CHECK_USER_CALL(glVertexStream4sATI)
        UCT.glVertexStream4sATI(param[0].uv32bit, param[1].v16bit, param[2].v16bit, param[3].v16bit, param[4].v16bit);
    CHECK_GL_CALL(glVertexStream4sATI)
        JT.glVertexStream4sATI(param[0].uv32bit, param[1].v16bit, param[2].v16bit, param[3].v16bit, param[4].v16bit);
}

void STUB_glVertexStream4svATI( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glVertexStream4svATI( GLenum, const GLshort * )
    maxParam = 2;
    char buffer0[16*4096];
    READ_ENUM_PARAM(0);
    READ_ARRAY_PARAM( 1, buffer0, TraceReader::TEXT_SHORT);
    TR.skipLine();
    CHECK_USER_CALL(glVertexStream4svATI)
        UCT.glVertexStream4svATI(param[0].uv32bit, (const GLshort *)param[1].ptr);
    CHECK_GL_CALL(glVertexStream4svATI)
        JT.glVertexStream4svATI(param[0].uv32bit, (const GLshort *)param[1].ptr);
}

void STUB_glVertexWeightPointerEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glVertexWeightPointerEXT( GLsizei, GLenum, GLsizei, const GLvoid * )
    maxParam = 4;
    char buffer0[16*4096];
    READ_PARAM(v32bit,0);
    READ_ENUM_PARAM(1);
    READ_PARAM(v32bit,2);
    READ_ARRAY_PARAM( 3, buffer0, TraceReader::TEXT_IGNORE);
    TR.skipLine();
    CHECK_USER_CALL(glVertexWeightPointerEXT)
        UCT.glVertexWeightPointerEXT(param[0].v32bit, param[1].uv32bit, param[2].v32bit, (const GLvoid *)param[3].ptr);
    CHECK_GL_CALL(glVertexWeightPointerEXT)
        JT.glVertexWeightPointerEXT(param[0].v32bit, param[1].uv32bit, param[2].v32bit, (const GLvoid *)param[3].ptr);
}

void STUB_glVertexWeightfEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glVertexWeightfEXT( GLfloat )
    maxParam = 1;
    READ_PARAM(fv32bit,0);
    TR.skipLine();
    CHECK_USER_CALL(glVertexWeightfEXT)
        UCT.glVertexWeightfEXT(param[0].fv32bit);
    CHECK_GL_CALL(glVertexWeightfEXT)
        JT.glVertexWeightfEXT(param[0].fv32bit);
}

void STUB_glVertexWeightfvEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glVertexWeightfvEXT( const GLfloat * )
    maxParam = 1;
    char buffer0[16*4096];
    READ_ARRAY_PARAM( 0, buffer0, TraceReader::TEXT_FLOAT);
    TR.skipLine();
    CHECK_USER_CALL(glVertexWeightfvEXT)
        UCT.glVertexWeightfvEXT((const GLfloat *)param[0].ptr);
    CHECK_GL_CALL(glVertexWeightfvEXT)
        JT.glVertexWeightfvEXT((const GLfloat *)param[0].ptr);
}

void STUB_glVertexWeighthNV( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glVertexWeighthNV( GLhalfNV )
    // Call not playable
    TR.skipCall();
}

void STUB_glVertexWeighthvNV( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glVertexWeighthvNV( const GLhalfNV * )
    // Call not playable
    TR.skipCall();
}

void STUB_glViewport( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glViewport( GLint x, GLint y, GLsizei width, GLsizei height )
    maxParam = 4;
    READ_PARAM(v32bit,0);
    READ_PARAM(v32bit,1);
    READ_PARAM(v32bit,2);
    READ_PARAM(v32bit,3);
    TR.skipLine();
    CHECK_USER_CALL(glViewport)
        UCT.glViewport(param[0].v32bit, param[1].v32bit, param[2].v32bit, param[3].v32bit);
    CHECK_GL_CALL(glViewport)
        JT.glViewport(param[0].v32bit, param[1].v32bit, param[2].v32bit, param[3].v32bit);
}

void STUB_glWeightPointerARB( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glWeightPointerARB( GLint, GLenum, GLsizei, const GLvoid * )
    maxParam = 4;
    char buffer0[16*4096];
    READ_PARAM(v32bit,0);
    READ_ENUM_PARAM(1);
    READ_PARAM(v32bit,2);
    READ_ARRAY_PARAM( 3, buffer0, TraceReader::TEXT_IGNORE);
    TR.skipLine();
    CHECK_USER_CALL(glWeightPointerARB)
        UCT.glWeightPointerARB(param[0].v32bit, param[1].uv32bit, param[2].v32bit, (const GLvoid *)param[3].ptr);
    CHECK_GL_CALL(glWeightPointerARB)
        JT.glWeightPointerARB(param[0].v32bit, param[1].uv32bit, param[2].v32bit, (const GLvoid *)param[3].ptr);
}

void STUB_glWeightbvARB( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glWeightbvARB( GLint, const GLbyte * )
    maxParam = 2;
    char buffer0[16*4096];
    READ_PARAM(v32bit,0);
    READ_ARRAY_PARAM( 1, buffer0, TraceReader::TEXT_BYTE);
    TR.skipLine();
    CHECK_USER_CALL(glWeightbvARB)
        UCT.glWeightbvARB(param[0].v32bit, (const GLbyte *)param[1].ptr);
    CHECK_GL_CALL(glWeightbvARB)
        JT.glWeightbvARB(param[0].v32bit, (const GLbyte *)param[1].ptr);
}

void STUB_glWeightdvARB( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glWeightdvARB( GLint, const GLdouble * )
    maxParam = 2;
    char buffer0[16*4096];
    READ_PARAM(v32bit,0);
    READ_ARRAY_PARAM( 1, buffer0, TraceReader::TEXT_DOUBLE);
    TR.skipLine();
    CHECK_USER_CALL(glWeightdvARB)
        UCT.glWeightdvARB(param[0].v32bit, (const GLdouble *)param[1].ptr);
    CHECK_GL_CALL(glWeightdvARB)
        JT.glWeightdvARB(param[0].v32bit, (const GLdouble *)param[1].ptr);
}

void STUB_glWeightfvARB( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glWeightfvARB( GLint, const GLfloat * )
    maxParam = 2;
    char buffer0[16*4096];
    READ_PARAM(v32bit,0);
    READ_ARRAY_PARAM( 1, buffer0, TraceReader::TEXT_FLOAT);
    TR.skipLine();
    CHECK_USER_CALL(glWeightfvARB)
        UCT.glWeightfvARB(param[0].v32bit, (const GLfloat *)param[1].ptr);
    CHECK_GL_CALL(glWeightfvARB)
        JT.glWeightfvARB(param[0].v32bit, (const GLfloat *)param[1].ptr);
}

void STUB_glWeightivARB( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glWeightivARB( GLint, const GLint * )
    maxParam = 2;
    char buffer0[16*4096];
    READ_PARAM(v32bit,0);
    READ_ARRAY_PARAM( 1, buffer0, TraceReader::TEXT_INT);
    TR.skipLine();
    CHECK_USER_CALL(glWeightivARB)
        UCT.glWeightivARB(param[0].v32bit, (const GLint *)param[1].ptr);
    CHECK_GL_CALL(glWeightivARB)
        JT.glWeightivARB(param[0].v32bit, (const GLint *)param[1].ptr);
}

void STUB_glWeightsvARB( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glWeightsvARB( GLint, const GLshort * )
    maxParam = 2;
    char buffer0[16*4096];
    READ_PARAM(v32bit,0);
    READ_ARRAY_PARAM( 1, buffer0, TraceReader::TEXT_SHORT);
    TR.skipLine();
    CHECK_USER_CALL(glWeightsvARB)
        UCT.glWeightsvARB(param[0].v32bit, (const GLshort *)param[1].ptr);
    CHECK_GL_CALL(glWeightsvARB)
        JT.glWeightsvARB(param[0].v32bit, (const GLshort *)param[1].ptr);
}

void STUB_glWeightubvARB( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glWeightubvARB( GLint, const GLubyte * )
    maxParam = 2;
    char buffer0[16*4096];
    READ_PARAM(v32bit,0);
    READ_ARRAY_PARAM( 1, buffer0, TraceReader::TEXT_BYTE);
    TR.skipLine();
    CHECK_USER_CALL(glWeightubvARB)
        UCT.glWeightubvARB(param[0].v32bit, (const GLubyte *)param[1].ptr);
    CHECK_GL_CALL(glWeightubvARB)
        JT.glWeightubvARB(param[0].v32bit, (const GLubyte *)param[1].ptr);
}

void STUB_glWeightuivARB( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glWeightuivARB( GLint, const GLuint * )
    maxParam = 2;
    char buffer0[16*4096];
    READ_PARAM(v32bit,0);
    READ_ARRAY_PARAM( 1, buffer0, TraceReader::TEXT_INT);
    TR.skipLine();
    CHECK_USER_CALL(glWeightuivARB)
        UCT.glWeightuivARB(param[0].v32bit, (const GLuint *)param[1].ptr);
    CHECK_GL_CALL(glWeightuivARB)
        JT.glWeightuivARB(param[0].v32bit, (const GLuint *)param[1].ptr);
}

void STUB_glWeightusvARB( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glWeightusvARB( GLint, const GLushort * )
    maxParam = 2;
    char buffer0[16*4096];
    READ_PARAM(v32bit,0);
    READ_ARRAY_PARAM( 1, buffer0, TraceReader::TEXT_SHORT);
    TR.skipLine();
    CHECK_USER_CALL(glWeightusvARB)
        UCT.glWeightusvARB(param[0].v32bit, (const GLushort *)param[1].ptr);
    CHECK_GL_CALL(glWeightusvARB)
        JT.glWeightusvARB(param[0].v32bit, (const GLushort *)param[1].ptr);
}

void STUB_glWindowPos2d( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glWindowPos2d( GLdouble, GLdouble )
    maxParam = 2;
    READ_DOUBLE_PARAM(0);
    READ_DOUBLE_PARAM(1);
    TR.skipLine();
    CHECK_USER_CALL(glWindowPos2d)
        UCT.glWindowPos2d(param[0].fv64bit, param[1].fv64bit);
    CHECK_GL_CALL(glWindowPos2d)
        JT.glWindowPos2d(param[0].fv64bit, param[1].fv64bit);
}

void STUB_glWindowPos2dARB( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glWindowPos2dARB( GLdouble, GLdouble )
    maxParam = 2;
    READ_DOUBLE_PARAM(0);
    READ_DOUBLE_PARAM(1);
    TR.skipLine();
    CHECK_USER_CALL(glWindowPos2dARB)
        UCT.glWindowPos2dARB(param[0].fv64bit, param[1].fv64bit);
    CHECK_GL_CALL(glWindowPos2dARB)
        JT.glWindowPos2dARB(param[0].fv64bit, param[1].fv64bit);
}

void STUB_glWindowPos2dv( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glWindowPos2dv( const GLdouble * )
    maxParam = 1;
    char buffer0[16*4096];
    READ_ARRAY_PARAM( 0, buffer0, TraceReader::TEXT_DOUBLE);
    TR.skipLine();
    CHECK_USER_CALL(glWindowPos2dv)
        UCT.glWindowPos2dv((const GLdouble *)param[0].ptr);
    CHECK_GL_CALL(glWindowPos2dv)
        JT.glWindowPos2dv((const GLdouble *)param[0].ptr);
}

void STUB_glWindowPos2dvARB( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glWindowPos2dvARB( const GLdouble * )
    maxParam = 1;
    char buffer0[16*4096];
    READ_ARRAY_PARAM( 0, buffer0, TraceReader::TEXT_DOUBLE);
    TR.skipLine();
    CHECK_USER_CALL(glWindowPos2dvARB)
        UCT.glWindowPos2dvARB((const GLdouble *)param[0].ptr);
    CHECK_GL_CALL(glWindowPos2dvARB)
        JT.glWindowPos2dvARB((const GLdouble *)param[0].ptr);
}

void STUB_glWindowPos2f( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glWindowPos2f( GLfloat, GLfloat )
    maxParam = 2;
    READ_PARAM(fv32bit,0);
    READ_PARAM(fv32bit,1);
    TR.skipLine();
    CHECK_USER_CALL(glWindowPos2f)
        UCT.glWindowPos2f(param[0].fv32bit, param[1].fv32bit);
    CHECK_GL_CALL(glWindowPos2f)
        JT.glWindowPos2f(param[0].fv32bit, param[1].fv32bit);
}

void STUB_glWindowPos2fARB( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glWindowPos2fARB( GLfloat, GLfloat )
    maxParam = 2;
    READ_PARAM(fv32bit,0);
    READ_PARAM(fv32bit,1);
    TR.skipLine();
    CHECK_USER_CALL(glWindowPos2fARB)
        UCT.glWindowPos2fARB(param[0].fv32bit, param[1].fv32bit);
    CHECK_GL_CALL(glWindowPos2fARB)
        JT.glWindowPos2fARB(param[0].fv32bit, param[1].fv32bit);
}

void STUB_glWindowPos2fv( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glWindowPos2fv( const GLfloat * )
    maxParam = 1;
    char buffer0[16*4096];
    READ_ARRAY_PARAM( 0, buffer0, TraceReader::TEXT_FLOAT);
    TR.skipLine();
    CHECK_USER_CALL(glWindowPos2fv)
        UCT.glWindowPos2fv((const GLfloat *)param[0].ptr);
    CHECK_GL_CALL(glWindowPos2fv)
        JT.glWindowPos2fv((const GLfloat *)param[0].ptr);
}

void STUB_glWindowPos2fvARB( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glWindowPos2fvARB( const GLfloat * )
    maxParam = 1;
    char buffer0[16*4096];
    READ_ARRAY_PARAM( 0, buffer0, TraceReader::TEXT_FLOAT);
    TR.skipLine();
    CHECK_USER_CALL(glWindowPos2fvARB)
        UCT.glWindowPos2fvARB((const GLfloat *)param[0].ptr);
    CHECK_GL_CALL(glWindowPos2fvARB)
        JT.glWindowPos2fvARB((const GLfloat *)param[0].ptr);
}

void STUB_glWindowPos2i( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glWindowPos2i( GLint, GLint )
    maxParam = 2;
    READ_PARAM(v32bit,0);
    READ_PARAM(v32bit,1);
    TR.skipLine();
    CHECK_USER_CALL(glWindowPos2i)
        UCT.glWindowPos2i(param[0].v32bit, param[1].v32bit);
    CHECK_GL_CALL(glWindowPos2i)
        JT.glWindowPos2i(param[0].v32bit, param[1].v32bit);
}

void STUB_glWindowPos2iARB( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glWindowPos2iARB( GLint, GLint )
    maxParam = 2;
    READ_PARAM(v32bit,0);
    READ_PARAM(v32bit,1);
    TR.skipLine();
    CHECK_USER_CALL(glWindowPos2iARB)
        UCT.glWindowPos2iARB(param[0].v32bit, param[1].v32bit);
    CHECK_GL_CALL(glWindowPos2iARB)
        JT.glWindowPos2iARB(param[0].v32bit, param[1].v32bit);
}

void STUB_glWindowPos2iv( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glWindowPos2iv( const GLint * )
    maxParam = 1;
    char buffer0[16*4096];
    READ_ARRAY_PARAM( 0, buffer0, TraceReader::TEXT_INT);
    TR.skipLine();
    CHECK_USER_CALL(glWindowPos2iv)
        UCT.glWindowPos2iv((const GLint *)param[0].ptr);
    CHECK_GL_CALL(glWindowPos2iv)
        JT.glWindowPos2iv((const GLint *)param[0].ptr);
}

void STUB_glWindowPos2ivARB( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glWindowPos2ivARB( const GLint * )
    maxParam = 1;
    char buffer0[16*4096];
    READ_ARRAY_PARAM( 0, buffer0, TraceReader::TEXT_INT);
    TR.skipLine();
    CHECK_USER_CALL(glWindowPos2ivARB)
        UCT.glWindowPos2ivARB((const GLint *)param[0].ptr);
    CHECK_GL_CALL(glWindowPos2ivARB)
        JT.glWindowPos2ivARB((const GLint *)param[0].ptr);
}

void STUB_glWindowPos2s( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glWindowPos2s( GLshort, GLshort )
    maxParam = 2;
    READ_PARAM(v16bit,0);
    READ_PARAM(v16bit,1);
    TR.skipLine();
    CHECK_USER_CALL(glWindowPos2s)
        UCT.glWindowPos2s(param[0].v16bit, param[1].v16bit);
    CHECK_GL_CALL(glWindowPos2s)
        JT.glWindowPos2s(param[0].v16bit, param[1].v16bit);
}

void STUB_glWindowPos2sARB( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glWindowPos2sARB( GLshort, GLshort )
    maxParam = 2;
    READ_PARAM(v16bit,0);
    READ_PARAM(v16bit,1);
    TR.skipLine();
    CHECK_USER_CALL(glWindowPos2sARB)
        UCT.glWindowPos2sARB(param[0].v16bit, param[1].v16bit);
    CHECK_GL_CALL(glWindowPos2sARB)
        JT.glWindowPos2sARB(param[0].v16bit, param[1].v16bit);
}

void STUB_glWindowPos2sv( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glWindowPos2sv( const GLshort * )
    maxParam = 1;
    char buffer0[16*4096];
    READ_ARRAY_PARAM( 0, buffer0, TraceReader::TEXT_SHORT);
    TR.skipLine();
    CHECK_USER_CALL(glWindowPos2sv)
        UCT.glWindowPos2sv((const GLshort *)param[0].ptr);
    CHECK_GL_CALL(glWindowPos2sv)
        JT.glWindowPos2sv((const GLshort *)param[0].ptr);
}

void STUB_glWindowPos2svARB( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glWindowPos2svARB( const GLshort * )
    maxParam = 1;
    char buffer0[16*4096];
    READ_ARRAY_PARAM( 0, buffer0, TraceReader::TEXT_SHORT);
    TR.skipLine();
    CHECK_USER_CALL(glWindowPos2svARB)
        UCT.glWindowPos2svARB((const GLshort *)param[0].ptr);
    CHECK_GL_CALL(glWindowPos2svARB)
        JT.glWindowPos2svARB((const GLshort *)param[0].ptr);
}

void STUB_glWindowPos3d( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glWindowPos3d( GLdouble, GLdouble, GLdouble )
    maxParam = 3;
    READ_DOUBLE_PARAM(0);
    READ_DOUBLE_PARAM(1);
    READ_DOUBLE_PARAM(2);
    TR.skipLine();
    CHECK_USER_CALL(glWindowPos3d)
        UCT.glWindowPos3d(param[0].fv64bit, param[1].fv64bit, param[2].fv64bit);
    CHECK_GL_CALL(glWindowPos3d)
        JT.glWindowPos3d(param[0].fv64bit, param[1].fv64bit, param[2].fv64bit);
}

void STUB_glWindowPos3dARB( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glWindowPos3dARB( GLdouble, GLdouble, GLdouble )
    maxParam = 3;
    READ_DOUBLE_PARAM(0);
    READ_DOUBLE_PARAM(1);
    READ_DOUBLE_PARAM(2);
    TR.skipLine();
    CHECK_USER_CALL(glWindowPos3dARB)
        UCT.glWindowPos3dARB(param[0].fv64bit, param[1].fv64bit, param[2].fv64bit);
    CHECK_GL_CALL(glWindowPos3dARB)
        JT.glWindowPos3dARB(param[0].fv64bit, param[1].fv64bit, param[2].fv64bit);
}

void STUB_glWindowPos3dv( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glWindowPos3dv( const GLdouble * )
    maxParam = 1;
    char buffer0[16*4096];
    READ_ARRAY_PARAM( 0, buffer0, TraceReader::TEXT_DOUBLE);
    TR.skipLine();
    CHECK_USER_CALL(glWindowPos3dv)
        UCT.glWindowPos3dv((const GLdouble *)param[0].ptr);
    CHECK_GL_CALL(glWindowPos3dv)
        JT.glWindowPos3dv((const GLdouble *)param[0].ptr);
}

void STUB_glWindowPos3dvARB( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glWindowPos3dvARB( const GLdouble * )
    maxParam = 1;
    char buffer0[16*4096];
    READ_ARRAY_PARAM( 0, buffer0, TraceReader::TEXT_DOUBLE);
    TR.skipLine();
    CHECK_USER_CALL(glWindowPos3dvARB)
        UCT.glWindowPos3dvARB((const GLdouble *)param[0].ptr);
    CHECK_GL_CALL(glWindowPos3dvARB)
        JT.glWindowPos3dvARB((const GLdouble *)param[0].ptr);
}

void STUB_glWindowPos3f( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glWindowPos3f( GLfloat, GLfloat, GLfloat )
    maxParam = 3;
    READ_PARAM(fv32bit,0);
    READ_PARAM(fv32bit,1);
    READ_PARAM(fv32bit,2);
    TR.skipLine();
    CHECK_USER_CALL(glWindowPos3f)
        UCT.glWindowPos3f(param[0].fv32bit, param[1].fv32bit, param[2].fv32bit);
    CHECK_GL_CALL(glWindowPos3f)
        JT.glWindowPos3f(param[0].fv32bit, param[1].fv32bit, param[2].fv32bit);
}

void STUB_glWindowPos3fARB( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glWindowPos3fARB( GLfloat, GLfloat, GLfloat )
    maxParam = 3;
    READ_PARAM(fv32bit,0);
    READ_PARAM(fv32bit,1);
    READ_PARAM(fv32bit,2);
    TR.skipLine();
    CHECK_USER_CALL(glWindowPos3fARB)
        UCT.glWindowPos3fARB(param[0].fv32bit, param[1].fv32bit, param[2].fv32bit);
    CHECK_GL_CALL(glWindowPos3fARB)
        JT.glWindowPos3fARB(param[0].fv32bit, param[1].fv32bit, param[2].fv32bit);
}

void STUB_glWindowPos3fv( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glWindowPos3fv( const GLfloat * )
    maxParam = 1;
    char buffer0[16*4096];
    READ_ARRAY_PARAM( 0, buffer0, TraceReader::TEXT_FLOAT);
    TR.skipLine();
    CHECK_USER_CALL(glWindowPos3fv)
        UCT.glWindowPos3fv((const GLfloat *)param[0].ptr);
    CHECK_GL_CALL(glWindowPos3fv)
        JT.glWindowPos3fv((const GLfloat *)param[0].ptr);
}

void STUB_glWindowPos3fvARB( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glWindowPos3fvARB( const GLfloat * )
    maxParam = 1;
    char buffer0[16*4096];
    READ_ARRAY_PARAM( 0, buffer0, TraceReader::TEXT_FLOAT);
    TR.skipLine();
    CHECK_USER_CALL(glWindowPos3fvARB)
        UCT.glWindowPos3fvARB((const GLfloat *)param[0].ptr);
    CHECK_GL_CALL(glWindowPos3fvARB)
        JT.glWindowPos3fvARB((const GLfloat *)param[0].ptr);
}

void STUB_glWindowPos3i( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glWindowPos3i( GLint, GLint, GLint )
    maxParam = 3;
    READ_PARAM(v32bit,0);
    READ_PARAM(v32bit,1);
    READ_PARAM(v32bit,2);
    TR.skipLine();
    CHECK_USER_CALL(glWindowPos3i)
        UCT.glWindowPos3i(param[0].v32bit, param[1].v32bit, param[2].v32bit);
    CHECK_GL_CALL(glWindowPos3i)
        JT.glWindowPos3i(param[0].v32bit, param[1].v32bit, param[2].v32bit);
}

void STUB_glWindowPos3iARB( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glWindowPos3iARB( GLint, GLint, GLint )
    maxParam = 3;
    READ_PARAM(v32bit,0);
    READ_PARAM(v32bit,1);
    READ_PARAM(v32bit,2);
    TR.skipLine();
    CHECK_USER_CALL(glWindowPos3iARB)
        UCT.glWindowPos3iARB(param[0].v32bit, param[1].v32bit, param[2].v32bit);
    CHECK_GL_CALL(glWindowPos3iARB)
        JT.glWindowPos3iARB(param[0].v32bit, param[1].v32bit, param[2].v32bit);
}

void STUB_glWindowPos3iv( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glWindowPos3iv( const GLint * )
    maxParam = 1;
    char buffer0[16*4096];
    READ_ARRAY_PARAM( 0, buffer0, TraceReader::TEXT_INT);
    TR.skipLine();
    CHECK_USER_CALL(glWindowPos3iv)
        UCT.glWindowPos3iv((const GLint *)param[0].ptr);
    CHECK_GL_CALL(glWindowPos3iv)
        JT.glWindowPos3iv((const GLint *)param[0].ptr);
}

void STUB_glWindowPos3ivARB( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glWindowPos3ivARB( const GLint * )
    maxParam = 1;
    char buffer0[16*4096];
    READ_ARRAY_PARAM( 0, buffer0, TraceReader::TEXT_INT);
    TR.skipLine();
    CHECK_USER_CALL(glWindowPos3ivARB)
        UCT.glWindowPos3ivARB((const GLint *)param[0].ptr);
    CHECK_GL_CALL(glWindowPos3ivARB)
        JT.glWindowPos3ivARB((const GLint *)param[0].ptr);
}

void STUB_glWindowPos3s( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glWindowPos3s( GLshort, GLshort, GLshort )
    maxParam = 3;
    READ_PARAM(v16bit,0);
    READ_PARAM(v16bit,1);
    READ_PARAM(v16bit,2);
    TR.skipLine();
    CHECK_USER_CALL(glWindowPos3s)
        UCT.glWindowPos3s(param[0].v16bit, param[1].v16bit, param[2].v16bit);
    CHECK_GL_CALL(glWindowPos3s)
        JT.glWindowPos3s(param[0].v16bit, param[1].v16bit, param[2].v16bit);
}

void STUB_glWindowPos3sARB( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glWindowPos3sARB( GLshort, GLshort, GLshort )
    maxParam = 3;
    READ_PARAM(v16bit,0);
    READ_PARAM(v16bit,1);
    READ_PARAM(v16bit,2);
    TR.skipLine();
    CHECK_USER_CALL(glWindowPos3sARB)
        UCT.glWindowPos3sARB(param[0].v16bit, param[1].v16bit, param[2].v16bit);
    CHECK_GL_CALL(glWindowPos3sARB)
        JT.glWindowPos3sARB(param[0].v16bit, param[1].v16bit, param[2].v16bit);
}

void STUB_glWindowPos3sv( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glWindowPos3sv( const GLshort * )
    maxParam = 1;
    char buffer0[16*4096];
    READ_ARRAY_PARAM( 0, buffer0, TraceReader::TEXT_SHORT);
    TR.skipLine();
    CHECK_USER_CALL(glWindowPos3sv)
        UCT.glWindowPos3sv((const GLshort *)param[0].ptr);
    CHECK_GL_CALL(glWindowPos3sv)
        JT.glWindowPos3sv((const GLshort *)param[0].ptr);
}

void STUB_glWindowPos3svARB( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glWindowPos3svARB( const GLshort * )
    maxParam = 1;
    char buffer0[16*4096];
    READ_ARRAY_PARAM( 0, buffer0, TraceReader::TEXT_SHORT);
    TR.skipLine();
    CHECK_USER_CALL(glWindowPos3svARB)
        UCT.glWindowPos3svARB((const GLshort *)param[0].ptr);
    CHECK_GL_CALL(glWindowPos3svARB)
        JT.glWindowPos3svARB((const GLshort *)param[0].ptr);
}

void STUB_glWriteMaskEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void glWriteMaskEXT( GLuint, GLuint, GLenum, GLenum, GLenum, GLenum )
    maxParam = 6;
    READ_ENUM_PARAM(0);
    READ_ENUM_PARAM(1);
    READ_ENUM_PARAM(2);
    READ_ENUM_PARAM(3);
    READ_ENUM_PARAM(4);
    READ_ENUM_PARAM(5);
    TR.skipLine();
    CHECK_USER_CALL(glWriteMaskEXT)
        UCT.glWriteMaskEXT(param[0].uv32bit, param[1].uv32bit, param[2].uv32bit, param[3].uv32bit, param[4].uv32bit, param[5].uv32bit);
    CHECK_GL_CALL(glWriteMaskEXT)
        JT.glWriteMaskEXT(param[0].uv32bit, param[1].uv32bit, param[2].uv32bit, param[3].uv32bit, param[4].uv32bit, param[5].uv32bit);
}

void STUB_wglAllocateMemoryNV( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void *wglAllocateMemoryNV( GLsizei, GLfloat, GLfloat, GLfloat )
    maxParam = 4;
    READ_PARAM(v32bit,0);
    READ_PARAM(fv32bit,1);
    READ_PARAM(fv32bit,2);
    READ_PARAM(fv32bit,3);
    TR.skipResult();
    TR.skipLine();
    CHECK_USER_CALL(wglAllocateMemoryNV)
        UCT.wglAllocateMemoryNV(param[0].v32bit, param[1].fv32bit, param[2].fv32bit, param[3].fv32bit);
    CHECK_GL_CALL(wglAllocateMemoryNV)
        JT.wglAllocateMemoryNV(param[0].v32bit, param[1].fv32bit, param[2].fv32bit, param[3].fv32bit);
}

void STUB_wglAssociateImageBufferEventsI3D( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // BOOL wglAssociateImageBufferEventsI3D( HDC, const HANDLE *, const LPVOID *, const DWORD *, UINT )
    // Call not playable
    TR.skipCall();
}

void STUB_wglBeginFrameTrackingI3D( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // BOOL wglBeginFrameTrackingI3D(  )
    maxParam = 0;
    TR.skipResult();
    TR.skipLine();
    CHECK_USER_CALL(wglBeginFrameTrackingI3D)
        UCT.wglBeginFrameTrackingI3D();
    CHECK_GL_CALL(wglBeginFrameTrackingI3D)
        JT.wglBeginFrameTrackingI3D();
}

void STUB_wglBindDisplayColorTableEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // GLboolean wglBindDisplayColorTableEXT( GLushort )
    maxParam = 1;
    READ_PARAM(uv16bit,0);
    TR.skipResult();
    TR.skipLine();
    CHECK_USER_CALL(wglBindDisplayColorTableEXT)
        UCT.wglBindDisplayColorTableEXT(param[0].uv16bit);
    CHECK_GL_CALL(wglBindDisplayColorTableEXT)
        JT.wglBindDisplayColorTableEXT(param[0].uv16bit);
}

void STUB_wglBindTexImageARB( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // BOOL wglBindTexImageARB( HPBUFFERARB, int )
    // Call not playable
    TR.skipCall();
}

void STUB_wglChoosePixelFormat( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // int wglChoosePixelFormat( HDC, const PIXELFORMATDESCRIPTOR * )
    // Call not playable
    TR.skipCall();
}

void STUB_wglChoosePixelFormatARB( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // BOOL wglChoosePixelFormatARB( HDC, const int *, const FLOAT *, UINT, int *, UINT * )
    // Call not playable
    TR.skipCall();
}

void STUB_wglChoosePixelFormatEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // BOOL wglChoosePixelFormatEXT( HDC, const int *, const FLOAT *, UINT, int *, UINT * )
    // Call not playable
    TR.skipCall();
}

void STUB_wglCopyContext( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // int wglCopyContext( HGLRC, HGLRC, unsigned int )
    // Call not playable
    TR.skipCall();
}

void STUB_wglCreateBufferRegionARB( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // HANDLE wglCreateBufferRegionARB( HDC, int, UINT )
    // Call not playable
    TR.skipCall();
}

void STUB_wglCreateContext( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // HGLRC wglCreateContext( HDC )
    // Call not playable
    TR.skipCall();
}

void STUB_wglCreateDisplayColorTableEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // GLboolean wglCreateDisplayColorTableEXT( GLushort )
    maxParam = 1;
    READ_PARAM(uv16bit,0);
    TR.skipResult();
    TR.skipLine();
    CHECK_USER_CALL(wglCreateDisplayColorTableEXT)
        UCT.wglCreateDisplayColorTableEXT(param[0].uv16bit);
    CHECK_GL_CALL(wglCreateDisplayColorTableEXT)
        JT.wglCreateDisplayColorTableEXT(param[0].uv16bit);
}

void STUB_wglCreateImageBufferI3D( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // LPVOID wglCreateImageBufferI3D( HDC, DWORD, UINT )
    // Call not playable
    TR.skipCall();
}

void STUB_wglCreateLayerContext( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // HGLRC wglCreateLayerContext( HDC, int )
    // Call not playable
    TR.skipCall();
}

void STUB_wglCreatePbufferARB( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // HPBUFFERARB wglCreatePbufferARB( HDC, int, int, int, const int * )
    // Call not playable
    TR.skipCall();
}

void STUB_wglCreatePbufferEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // HPBUFFEREXT wglCreatePbufferEXT( HDC, int, int, int, const int * )
    // Call not playable
    TR.skipCall();
}

void STUB_wglDeleteBufferRegionARB( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void wglDeleteBufferRegionARB( HANDLE )
    // Call not playable
    TR.skipCall();
}

void STUB_wglDeleteContext( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // int wglDeleteContext( HGLRC )
    // Call not playable
    TR.skipCall();
}

void STUB_wglDescribeLayerPlane( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // int wglDescribeLayerPlane( HDC, int, int, unsigned int, LPLAYERPLANEDESCRIPTOR )
    // Call not playable
    TR.skipCall();
}

void STUB_wglDescribePixelFormat( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // int wglDescribePixelFormat( HDC, int, unsigned int, LPPIXELFORMATDESCRIPTOR )
    // Call not playable
    TR.skipCall();
}

void STUB_wglDestroyDisplayColorTableEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void wglDestroyDisplayColorTableEXT( GLushort )
    maxParam = 1;
    READ_PARAM(uv16bit,0);
    TR.skipLine();
    CHECK_USER_CALL(wglDestroyDisplayColorTableEXT)
        UCT.wglDestroyDisplayColorTableEXT(param[0].uv16bit);
    CHECK_GL_CALL(wglDestroyDisplayColorTableEXT)
        JT.wglDestroyDisplayColorTableEXT(param[0].uv16bit);
}

void STUB_wglDestroyImageBufferI3D( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // BOOL wglDestroyImageBufferI3D( HDC, LPVOID )
    // Call not playable
    TR.skipCall();
}

void STUB_wglDestroyPbufferARB( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // BOOL wglDestroyPbufferARB( HPBUFFERARB )
    // Call not playable
    TR.skipCall();
}

void STUB_wglDestroyPbufferEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // BOOL wglDestroyPbufferEXT( HPBUFFEREXT )
    // Call not playable
    TR.skipCall();
}

void STUB_wglDisableFrameLockI3D( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // BOOL wglDisableFrameLockI3D(  )
    maxParam = 0;
    TR.skipResult();
    TR.skipLine();
    CHECK_USER_CALL(wglDisableFrameLockI3D)
        UCT.wglDisableFrameLockI3D();
    CHECK_GL_CALL(wglDisableFrameLockI3D)
        JT.wglDisableFrameLockI3D();
}

void STUB_wglDisableGenlockI3D( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // BOOL wglDisableGenlockI3D( HDC )
    // Call not playable
    TR.skipCall();
}

void STUB_wglEnableFrameLockI3D( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // BOOL wglEnableFrameLockI3D(  )
    maxParam = 0;
    TR.skipResult();
    TR.skipLine();
    CHECK_USER_CALL(wglEnableFrameLockI3D)
        UCT.wglEnableFrameLockI3D();
    CHECK_GL_CALL(wglEnableFrameLockI3D)
        JT.wglEnableFrameLockI3D();
}

void STUB_wglEnableGenlockI3D( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // BOOL wglEnableGenlockI3D( HDC )
    // Call not playable
    TR.skipCall();
}

void STUB_wglEndFrameTrackingI3D( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // BOOL wglEndFrameTrackingI3D(  )
    maxParam = 0;
    TR.skipResult();
    TR.skipLine();
    CHECK_USER_CALL(wglEndFrameTrackingI3D)
        UCT.wglEndFrameTrackingI3D();
    CHECK_GL_CALL(wglEndFrameTrackingI3D)
        JT.wglEndFrameTrackingI3D();
}

void STUB_wglFreeMemoryNV( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // void wglFreeMemoryNV( void * )
    maxParam = 1;
    char buffer0[16*4096];
    READ_ARRAY_PARAM( 0, buffer0, TraceReader::TEXT_IGNORE);
    TR.skipLine();
    CHECK_USER_CALL(wglFreeMemoryNV)
        UCT.wglFreeMemoryNV((void *)param[0].ptr);
    CHECK_GL_CALL(wglFreeMemoryNV)
        JT.wglFreeMemoryNV((void *)param[0].ptr);
}

void STUB_wglGenlockSampleRateI3D( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // BOOL wglGenlockSampleRateI3D( HDC, UINT )
    // Call not playable
    TR.skipCall();
}

void STUB_wglGenlockSourceDelayI3D( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // BOOL wglGenlockSourceDelayI3D( HDC, UINT )
    // Call not playable
    TR.skipCall();
}

void STUB_wglGenlockSourceEdgeI3D( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // BOOL wglGenlockSourceEdgeI3D( HDC, UINT )
    // Call not playable
    TR.skipCall();
}

void STUB_wglGenlockSourceI3D( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // BOOL wglGenlockSourceI3D( HDC, UINT )
    // Call not playable
    TR.skipCall();
}

void STUB_wglGetCurrentContext( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // HGLRC wglGetCurrentContext(  )
    maxParam = 0;
    TR.skipResult();
    TR.skipLine();
    CHECK_USER_CALL(wglGetCurrentContext)
        UCT.wglGetCurrentContext();
    CHECK_GL_CALL(wglGetCurrentContext)
        JT.wglGetCurrentContext();
}

void STUB_wglGetCurrentDC( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // HDC wglGetCurrentDC(  )
    maxParam = 0;
    TR.skipResult();
    TR.skipLine();
    CHECK_USER_CALL(wglGetCurrentDC)
        UCT.wglGetCurrentDC();
    CHECK_GL_CALL(wglGetCurrentDC)
        JT.wglGetCurrentDC();
}

void STUB_wglGetCurrentReadDCARB( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // HDC wglGetCurrentReadDCARB(  )
    maxParam = 0;
    TR.skipResult();
    TR.skipLine();
    CHECK_USER_CALL(wglGetCurrentReadDCARB)
        UCT.wglGetCurrentReadDCARB();
    CHECK_GL_CALL(wglGetCurrentReadDCARB)
        JT.wglGetCurrentReadDCARB();
}

void STUB_wglGetCurrentReadDCEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // HDC wglGetCurrentReadDCEXT(  )
    maxParam = 0;
    TR.skipResult();
    TR.skipLine();
    CHECK_USER_CALL(wglGetCurrentReadDCEXT)
        UCT.wglGetCurrentReadDCEXT();
    CHECK_GL_CALL(wglGetCurrentReadDCEXT)
        JT.wglGetCurrentReadDCEXT();
}

void STUB_wglGetDigitalVideoParametersI3D( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // BOOL wglGetDigitalVideoParametersI3D( HDC, int, int * )
    // Call not playable
    TR.skipCall();
}

void STUB_wglGetExtensionsStringARB( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // const char *wglGetExtensionsStringARB( HDC )
    // Call not playable
    TR.skipCall();
}

void STUB_wglGetExtensionsStringEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // const char *wglGetExtensionsStringEXT(  )
    maxParam = 0;
    TR.skipResult();
    TR.skipLine();
    CHECK_USER_CALL(wglGetExtensionsStringEXT)
        UCT.wglGetExtensionsStringEXT();
    CHECK_GL_CALL(wglGetExtensionsStringEXT)
        JT.wglGetExtensionsStringEXT();
}

void STUB_wglGetFrameUsageI3D( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // BOOL wglGetFrameUsageI3D( float * )
    maxParam = 1;
    char buffer0[16*4096];
    READ_ARRAY_PARAM( 0, buffer0, TraceReader::TEXT_FLOAT);
    TR.skipResult();
    TR.skipLine();
    CHECK_USER_CALL(wglGetFrameUsageI3D)
        UCT.wglGetFrameUsageI3D((float *)param[0].ptr);
    CHECK_GL_CALL(wglGetFrameUsageI3D)
        JT.wglGetFrameUsageI3D((float *)param[0].ptr);
}

void STUB_wglGetGammaTableI3D( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // BOOL wglGetGammaTableI3D( HDC, int, USHORT *, USHORT *, USHORT * )
    // Call not playable
    TR.skipCall();
}

void STUB_wglGetGammaTableParametersI3D( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // BOOL wglGetGammaTableParametersI3D( HDC, int, int * )
    // Call not playable
    TR.skipCall();
}

void STUB_wglGetGenlockSampleRateI3D( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // BOOL wglGetGenlockSampleRateI3D( HDC, UINT * )
    // Call not playable
    TR.skipCall();
}

void STUB_wglGetGenlockSourceDelayI3D( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // BOOL wglGetGenlockSourceDelayI3D( HDC, UINT * )
    // Call not playable
    TR.skipCall();
}

void STUB_wglGetGenlockSourceEdgeI3D( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // BOOL wglGetGenlockSourceEdgeI3D( HDC, UINT * )
    // Call not playable
    TR.skipCall();
}

void STUB_wglGetGenlockSourceI3D( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // BOOL wglGetGenlockSourceI3D( HDC, UINT * )
    // Call not playable
    TR.skipCall();
}

void STUB_wglGetLayerPaletteEntries( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // int wglGetLayerPaletteEntries( HDC, int, int, int, COLORREF * )
    // Call not playable
    TR.skipCall();
}

void STUB_wglGetMscRateOML( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // BOOL wglGetMscRateOML( HDC, INT32 *, INT32 * )
    // Call not playable
    TR.skipCall();
}

void STUB_wglGetPbufferDCARB( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // HDC wglGetPbufferDCARB( HPBUFFERARB )
    // Call not playable
    TR.skipCall();
}

void STUB_wglGetPbufferDCEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // HDC wglGetPbufferDCEXT( HPBUFFEREXT )
    // Call not playable
    TR.skipCall();
}

void STUB_wglGetPixelFormat( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // int wglGetPixelFormat( HDC hdc )
    // Call not playable
    TR.skipCall();
}

void STUB_wglGetPixelFormatAttribfvARB( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // BOOL wglGetPixelFormatAttribfvARB( HDC, int, int, UINT, const int *, FLOAT * )
    // Call not playable
    TR.skipCall();
}

void STUB_wglGetPixelFormatAttribfvEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // BOOL wglGetPixelFormatAttribfvEXT( HDC, int, int, UINT, int *, FLOAT * )
    // Call not playable
    TR.skipCall();
}

void STUB_wglGetPixelFormatAttribivARB( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // BOOL wglGetPixelFormatAttribivARB( HDC, int, int, UINT, const int *, int * )
    // Call not playable
    TR.skipCall();
}

void STUB_wglGetPixelFormatAttribivEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // BOOL wglGetPixelFormatAttribivEXT( HDC, int, int, UINT, int *, int * )
    // Call not playable
    TR.skipCall();
}

void STUB_wglGetProcAddress( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // PROC wglGetProcAddress( const char * )
    maxParam = 1;
    char buffer0[16*4096];
    READ_ARRAY_PARAM( 0, buffer0, TraceReader::TEXT_BYTE);
    TR.skipResult();
    TR.skipLine();
    CHECK_USER_CALL(wglGetProcAddress)
        UCT.wglGetProcAddress((const char *)param[0].ptr);
    CHECK_GL_CALL(wglGetProcAddress)
        JT.wglGetProcAddress((const char *)param[0].ptr);
}

void STUB_wglGetSwapIntervalEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // int wglGetSwapIntervalEXT(  )
    maxParam = 0;
    TR.skipResult();
    TR.skipLine();
    CHECK_USER_CALL(wglGetSwapIntervalEXT)
        UCT.wglGetSwapIntervalEXT();
    CHECK_GL_CALL(wglGetSwapIntervalEXT)
        JT.wglGetSwapIntervalEXT();
}

void STUB_wglGetSyncValuesOML( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // BOOL wglGetSyncValuesOML( HDC, INT64 *, INT64 *, INT64 * )
    // Call not playable
    TR.skipCall();
}

void STUB_wglIsEnabledFrameLockI3D( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // BOOL wglIsEnabledFrameLockI3D( BOOL * )
    maxParam = 1;
    char buffer0[16*4096];
    READ_ARRAY_PARAM( 0, buffer0, TraceReader::TEXT_BYTE);
    TR.skipResult();
    TR.skipLine();
    CHECK_USER_CALL(wglIsEnabledFrameLockI3D)
        UCT.wglIsEnabledFrameLockI3D((BOOL *)param[0].ptr);
    CHECK_GL_CALL(wglIsEnabledFrameLockI3D)
        JT.wglIsEnabledFrameLockI3D((BOOL *)param[0].ptr);
}

void STUB_wglIsEnabledGenlockI3D( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // BOOL wglIsEnabledGenlockI3D( HDC, BOOL * )
    // Call not playable
    TR.skipCall();
}

void STUB_wglLoadDisplayColorTableEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // GLboolean wglLoadDisplayColorTableEXT( const GLushort *, GLuint )
    maxParam = 2;
    char buffer0[16*4096];
    READ_ARRAY_PARAM( 0, buffer0, TraceReader::TEXT_SHORT);
    READ_ENUM_PARAM(1);
    TR.skipResult();
    TR.skipLine();
    CHECK_USER_CALL(wglLoadDisplayColorTableEXT)
        UCT.wglLoadDisplayColorTableEXT((const GLushort *)param[0].ptr, param[1].uv32bit);
    CHECK_GL_CALL(wglLoadDisplayColorTableEXT)
        JT.wglLoadDisplayColorTableEXT((const GLushort *)param[0].ptr, param[1].uv32bit);
}

void STUB_wglMakeContextCurrentARB( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // BOOL wglMakeContextCurrentARB( HDC, HDC, HGLRC )
    // Call not playable
    TR.skipCall();
}

void STUB_wglMakeContextCurrentEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // BOOL wglMakeContextCurrentEXT( HDC, HDC, HGLRC )
    // Call not playable
    TR.skipCall();
}

void STUB_wglMakeCurrent( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // int wglMakeCurrent( HDC, HGLRC )
    // Call not playable
    TR.skipCall();
}

void STUB_wglQueryFrameLockMasterI3D( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // BOOL wglQueryFrameLockMasterI3D( BOOL * )
    maxParam = 1;
    char buffer0[16*4096];
    READ_ARRAY_PARAM( 0, buffer0, TraceReader::TEXT_BYTE);
    TR.skipResult();
    TR.skipLine();
    CHECK_USER_CALL(wglQueryFrameLockMasterI3D)
        UCT.wglQueryFrameLockMasterI3D((BOOL *)param[0].ptr);
    CHECK_GL_CALL(wglQueryFrameLockMasterI3D)
        JT.wglQueryFrameLockMasterI3D((BOOL *)param[0].ptr);
}

void STUB_wglQueryFrameTrackingI3D( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // BOOL wglQueryFrameTrackingI3D( DWORD *, DWORD *, float * )
    // Call not playable
    TR.skipCall();
}

void STUB_wglQueryGenlockMaxSourceDelayI3D( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // BOOL wglQueryGenlockMaxSourceDelayI3D( HDC, UINT *, UINT * )
    // Call not playable
    TR.skipCall();
}

void STUB_wglQueryPbufferARB( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // BOOL wglQueryPbufferARB( HPBUFFERARB, int, int * )
    // Call not playable
    TR.skipCall();
}

void STUB_wglQueryPbufferEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // BOOL wglQueryPbufferEXT( HPBUFFEREXT, int, int * )
    // Call not playable
    TR.skipCall();
}

void STUB_wglRealizeLayerPalette( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // int wglRealizeLayerPalette( HDC, int, int )
    // Call not playable
    TR.skipCall();
}

void STUB_wglReleaseImageBufferEventsI3D( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // BOOL wglReleaseImageBufferEventsI3D( HDC, const LPVOID *, UINT )
    // Call not playable
    TR.skipCall();
}

void STUB_wglReleasePbufferDCARB( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // int wglReleasePbufferDCARB( HPBUFFERARB, HDC )
    // Call not playable
    TR.skipCall();
}

void STUB_wglReleasePbufferDCEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // int wglReleasePbufferDCEXT( HPBUFFEREXT, HDC )
    // Call not playable
    TR.skipCall();
}

void STUB_wglReleaseTexImageARB( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // BOOL wglReleaseTexImageARB( HPBUFFERARB, int )
    // Call not playable
    TR.skipCall();
}

void STUB_wglRestoreBufferRegionARB( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // BOOL wglRestoreBufferRegionARB( HANDLE, int, int, int, int, int, int )
    // Call not playable
    TR.skipCall();
}

void STUB_wglSaveBufferRegionARB( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // BOOL wglSaveBufferRegionARB( HANDLE, int, int, int, int )
    // Call not playable
    TR.skipCall();
}

void STUB_wglSetDigitalVideoParametersI3D( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // BOOL wglSetDigitalVideoParametersI3D( HDC, int, const int * )
    // Call not playable
    TR.skipCall();
}

void STUB_wglSetGammaTableI3D( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // BOOL wglSetGammaTableI3D( HDC, int, const USHORT *, const USHORT *, const USHORT * )
    // Call not playable
    TR.skipCall();
}

void STUB_wglSetGammaTableParametersI3D( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // BOOL wglSetGammaTableParametersI3D( HDC, int, const int * )
    // Call not playable
    TR.skipCall();
}

void STUB_wglSetLayerPaletteEntries( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // int wglSetLayerPaletteEntries( HDC, int, int, int, const COLORREF * )
    // Call not playable
    TR.skipCall();
}

void STUB_wglSetPbufferAttribARB( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // BOOL wglSetPbufferAttribARB( HPBUFFERARB, const int * )
    // Call not playable
    TR.skipCall();
}

void STUB_wglSetPixelFormat( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // int wglSetPixelFormat( HDC, int, const PIXELFORMATDESCRIPTOR * )
    // Call not playable
    TR.skipCall();
}

void STUB_wglShareLists( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // int wglShareLists( HGLRC, HGLRC )
    // Call not playable
    TR.skipCall();
}

void STUB_wglSwapBuffers( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // int wglSwapBuffers( HDC hdc )
    // Call not playable
    TR.skipCall();
}

void STUB_wglSwapBuffersMscOML( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // INT64 wglSwapBuffersMscOML( HDC, INT64, INT64, INT64 )
    // Call not playable
    TR.skipCall();
}

void STUB_wglSwapIntervalEXT( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // BOOL wglSwapIntervalEXT( int )
    maxParam = 1;
    READ_PARAM(v32bit,0);
    TR.skipResult();
    TR.skipLine();
    CHECK_USER_CALL(wglSwapIntervalEXT)
        UCT.wglSwapIntervalEXT(param[0].v32bit);
    CHECK_GL_CALL(wglSwapIntervalEXT)
        JT.wglSwapIntervalEXT(param[0].v32bit);
}

void STUB_wglSwapLayerBuffers( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // int wglSwapLayerBuffers( HDC, unsigned int )
    // Call not playable
    TR.skipCall();
}

void STUB_wglSwapLayerBuffersMscOML( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // INT64 wglSwapLayerBuffersMscOML( HDC, int, INT64, INT64, INT64 )
    // Call not playable
    TR.skipCall();
}

void STUB_wglUseFontBitmapsA( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // int wglUseFontBitmapsA( HDC, unsigned long, unsigned long, unsigned long )
    // Call not playable
    TR.skipCall();
}

void STUB_wglUseFontBitmapsW( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // int wglUseFontBitmapsW( HDC, unsigned long, unsigned long, unsigned long )
    // Call not playable
    TR.skipCall();
}

void STUB_wglUseFontOutlinesA( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // int wglUseFontOutlinesA( HDC, unsigned long, unsigned long, unsigned long, float, float, int, LPGLYPHMETRICSFLOAT )
    // Call not playable
    TR.skipCall();
}

void STUB_wglUseFontOutlinesW( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // int wglUseFontOutlinesW( HDC, unsigned long, unsigned long, unsigned long, float, float, int, LPGLYPHMETRICSFLOAT )
    // Call not playable
    TR.skipCall();
}

void STUB_wglWaitForMscOML( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // BOOL wglWaitForMscOML( HDC, INT64, INT64, INT64, INT64 *, INT64 *, INT64 * )
    // Call not playable
    TR.skipCall();
}

void STUB_wglWaitForSbcOML( TraceReader& TR, GLJumpTable& JT, GLJumpTable& UCT )
{
    // BOOL wglWaitForSbcOML( HDC, INT64, INT64 *, INT64 *, INT64 * )
    // Call not playable
    TR.skipCall();
}

